Golang Data Types: int, float64, string, bool, byte, rune

Go's basic types are numbers, booleans and strings. Every variable has exactly one type, fixed at compile time, and Go never converts between types for you. %T prints the type of any value:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

Notice 'G' prints as 71 with type int32: a single-quoted character is a rune, which is a number (the Unicode code point). rune is an alias for int32 (the same type under a second name), so %T reports int32. Likewise byte reports uint8.

Integers

Use int by default. len() returns int, slice indexes are int, and loop counters are int. On every 64-bit platform int is 64 bits. Reach for sized types when the size is part of a contract: int32 in a binary file format, uint8 for raw bytes, int64 for a Unix timestamp in nanoseconds.

Avoid unsigned types for quantities that "cannot be negative", such as counts. Subtracting past zero wraps to a huge number instead of producing a negative one you could catch.

Limits and overflow

The math package has a constant for every limit. At run time, integer arithmetic that overflows wraps around silently:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

No panic, no error: 127 + 1 becomes -128. Only constant expressions are checked at compile time (var b int8 = 128 does not compile). If overflow is possible in your data, check before the operation or use math/big.

Integer literals

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Floating-Point Numbers

A literal with a decimal point or exponent (2.5, 1e6) is float64 by default, and the math package takes and returns float64. Use it unless memory in a large array matters.

Floats are binary, so most decimal fractions are approximations:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

Two rules follow. Never compare floats with == after arithmetic. And never store money in a float: use an integer number of cents, or a decimal library.

Dividing a float by zero gives +Inf, -Inf or NaN instead of panicking. Dividing an integer by zero panics at run time (runtime error: integer divide by zero), and a constant zero divisor is a compile error.

Booleans

bool holds true or false, and its zero value is false. Go does not treat numbers, empty strings or nil as booleans. if count {} is a compile error; write if count > 0 {}. The operators are &&, || and !, and && and || short-circuit.

Strings

A string is an immutable sequence of bytes, usually UTF-8 text. len(s) counts bytes, not characters:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é takes two bytes in UTF-8, so len reports 6 for five characters. Double-quoted strings process escapes like \n; backquoted raw strings do not, and can span lines. The strings page covers the strings package, and runes and bytes covers UTF-8 in depth.

byte and rune

They are aliases, not new types: a byte and a uint8 are interchangeable without conversion. The names say what the number means.

Complex Numbers

Go has built-in complex types, complex64 and complex128, with real, imag and the math/cmplx package:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Few programs need them, but signal processing and some numeric code do.

Composite and Reference Types

The basic types combine into composite ones. Each has its own page:

any is an alias for interface{} (since Go 1.18) and can hold a value of any type.

Named Types

You can define a new type from an existing one. It has the same representation but is a distinct type, and it can have methods:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

That strictness is the point: a UserID cannot be passed where an OrderID is expected by accident. Convert explicitly when you mean it: float64(t). See type conversion for the rules and the strconv functions for going between numbers and strings.

Zero Values

Every type has a zero value, which is what a variable holds before you assign anything: 0 for numbers, false for bool, "" for strings, and nil for pointers, slices, maps, channels, functions and interfaces. There are no uninitialized variables in Go.