# Learning Golang: Basic data types

This is part 9 of my journey learning Golang.

Data types are a designation by a programming language about the kind of values that are being stored.

Go has several basic data types built in. This article explores boolean, numeric and string data types. See Go’s documentation for more details.

# Boolean data type

Boolean values can be either `false`

(equivalent to 0) or `true`

(equivalent to 1). Although in principle they only require
1 bit of storage, Go uses a byte for convenience reasons.

Data type | Number of bits | Minimum value | Maximum value |
---|---|---|---|

bool | 8 | `false` |
`true` |

# Numeric data types

There are three categories of numeric data types in Go:

- Integer (whole numbers)
- Floating point (numbers with a fractionary part)
- Complex (imaginary numbers)

## Integer numbers

These represent whole numbers. Integer data types have different lenghts and can be signed or unsigned:

Data type | Number of bits | Minimum value | Maximum value |
---|---|---|---|

int8 | 8 | -128 | 127 |

int16 | 16 | -32,768 | 32,767 |

int32 | 32 | -2,147,483,648 | 2,147,483,647 |

int64 | 64 | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |

uint8 | 8 | 0 | 255 |

uint16 | 16 | 0 | 65,535 |

uint32 | 32 | 0 | 4,294,967,295 |

uint64 | 64 | 0 | 18,446,744,073,709,551,615 |

There are also aliases for some of the above data types:

`byte`

: alias for`uint8`

`rune`

: alias for`int32`

(represents a Unicode code point (loosely, a “character”)`int`

: alias for`int32`

or`int64`

depending on the platform`uint`

: alias for`uint32`

or`uint64`

depending on the platform

Most current computers are 64-bit systems. On those systems, `int`

and `uint`

will be 64-bit integers. On other (older
or special-purpose) 32-bit systems, `int`

and `uint`

will be 32 bits in size.

## Floating-point numbers

These represent numbers that may have a fractional part. They don’t have a minimum or maximum value, but they have different levels of precision (accuracy) for representing numbers.

Data type | Number of bits | Precision | Exponent length | Fraction length |
---|---|---|---|---|

float32 | 32 | single | 8 | 23 |

float64 | 64 | double | 11 | 52 |

Hint: Floating point data types are binary numbers. They can present rounding errors when storing decimal numbers. For applications that require guaranteed precision for decimal values (like currency) see the decimal package.

## Complex numbers

These represent numbers with an imaginary part. They’re useful for computations on 2-dimensional space and calculations involving square roots.

Data type | Number of bits | Range |
---|---|---|

complex64 | 64 | complex numbers with float32 real and imaginary parts |

complex128 | 128 | complex numbers with float64 real and imaginary parts |

# String

Go strings are “a read-only slice of bytes”, i.e. a contiguous sequence of bytes – `uint8`

integers.

It’s important to notice that these can be arbitrary bytes. They don’t have to be Unicode code points and they don’t have to be encoded as UTF-8 or any other encoding. That said, Go’s library functions assume that strings are encoded as UTF-8. See this blog post for more details.

Data type | Content | Length |
---|---|---|

string | bytes (uint8) | 0 to maximum int value |

# Takeaways

Go offers several built-in data types. Each one is suited for different use cases:

`bool`

for boolean logic (true and false values)- signed and unsigned integers of different sizes for fast, memory-efficient arithmetic with whole numbers
- two levels of precision for numbers with a fractional part
- two different lengths for complex numbers
`string`

for sequences of bytes

This level of specialization (particularly of the numeric data types) can be overwhelming at first, and requires understanding the types and ranges of data that the aplication will handle. The trade-off is being able to produce faster-running programs that require less memory in comparison with equivalent programs in languages with a more lax type system.

comments powered by Disqus