Basic types: numbers, strings, bools, conversion

Go has fifteen number types, and it never converts between them on its own: adding an int to an int64 does not compile, even where both are 64 bits wide. The strictness is deliberate, because the type of a number decides how big it can get, whether it keeps a fraction, and what happens when a result does not fit.

You will choose a type for each kind of number, convert between types and to and from text, and see why the length of a string counts bytes and why no number can stand in for a bool.

Each number type has a fixed size and range

Integers come in four sizes, 8, 16, 32 and 64 bits, each signed, int8 to int64, or unsigned, uint8 to uint64. int and uint are 32 or 64 bits wide depending on the platform, and 64 on 64-bit machines. byte is another name for uint8, and rune, which holds one Unicode character, another name for int32. Fractions go in float32 or float64. This program prints the ranges on a 64-bit Mac:

// types.go: the sizes and ranges of Go's number types, and two aliases.
package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	fmt.Println("int has", strconv.IntSize, "bits here, up to", math.MaxInt)
	fmt.Println("int8: ", math.MinInt8, "to", math.MaxInt8)
	fmt.Println("uint8:", 0, "to", math.MaxUint8)
	fmt.Println("int32:", math.MinInt32, "to", math.MaxInt32)
	fmt.Println("int64:", math.MinInt64, "to", math.MaxInt64)
	fmt.Println("uint64: 0 to", uint64(math.MaxUint64)) // too big for int, so it is converted

	var b byte = 'A'
	var r rune = '€'
	fmt.Printf("byte is %T, 'A' is %d; rune is %T, '€' is %d\n", b, b, r, r)

	third := 1.0 / 3
	fmt.Println("one third:", float32(third), "as float32,", third, "as float64")
}

int has 64 bits here, up to 9223372036854775807
int8:  -128 to 127
uint8: 0 to 255
int32: -2147483648 to 2147483647
int64: -9223372036854775808 to 9223372036854775807
uint64: 0 to 18446744073709551615
byte is uint8, 'A' is 65; rune is int32, '€' is 8364
one third: 0.33333334 as float32, 0.3333333333333333 as float64

%T names the aliases by their real types, uint8 and int32, and ‘€’ is code point 8364. The last line shows the precision: a float32 prints one third as 0.33333334, a float64 as 0.3333333333333333. Choose a type by what the number holds. Answer the two questions for one number of your own:

In short: int for counts and positions, a sized type where a file format fixes the width, rune for characters and float64 for measurements. Money goes in an int64 as whole cents, the smallest unit of the currency, because float64 cannot hold 0.10 exactly. A result past a type’s range does not stop the program: it wraps around, so a uint8 at 255 plus 1 is 0. At run time nothing warns when that happens, so choose a type wide enough for the largest value the program will ever hold.

Go converts only where you write a conversion

A conversionconversion: An expression such as int64(seats) that makes a value of the named type from another value. Go converts between types only where the code writes a conversion; untyped constants are the one exception. is the name of a type used like a function: int64(seats) makes an int64 from an int. Go never adds one for you, so even int and int64 cannot meet in one expression:

// mismatch.go: an int and an int64 in one expression.
package main

import "fmt"

func main() {
	var seats int = 72
	var berths int64 = 8
	fmt.Println(seats + berths)
}

# command-line-arguments
./mismatch.go:9:14: invalid operation: seats + berths (mismatched types int and int64)

The fix is a conversion on one side. This program converts between number types and between numbers and text:

// conversions.go: Go converts between types only where you write it.
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var seats int = 72
	var berths int64 = 8
	total := int64(seats) + berths // int and int64 do not mix without a conversion
	fmt.Println("total:", total)

	perCoach := float64(seats) / 5 // 72 / 5 with integers would be 14
	fmt.Println("per coach:", perCoach, "as int:", int(perCoach))
	debt := -2.9
	fmt.Println("int(-2.9):", int(debt)) // the fraction is dropped, toward zero

	code := 65
	fmt.Println(string(rune(code)), strconv.Itoa(code)) // the character 65, and 65 as text
	n, err := strconv.Atoi("72")
	fmt.Println(n+1, err)
	_, err = strconv.Atoi("seventy")
	fmt.Println(err)
}

total: 80
per coach: 14.4 as int: 14
int(-2.9): -2
A 65
73 <nil>
strconv.Atoi: parsing "seventy": invalid syntax

A float converts to an integer by dropping its fraction, toward zero: int(14.4) is 14 and int(-2.9) is -2. An untyped constantuntyped constant: A constant with no type yet, such as 5, 2.5 or "hi". It takes the type its use needs, as long as its value fits that type, and has a default type, such as int or float64, where nothing else gives it one. More in “Constants, untyped values and iota” such as 5 has no type of its own, so it takes the type of the other operand without a conversion. Step through that division:

Between numbers and text, use the package strconv: strconv.Itoa(65) gives “65”, and strconv.Atoi reads text back, with an error for text that is not a whole number. string(65) gives “A”, the character with code 65, which is almost never what was meant. go vet reports it:

// stringint.go: string(n) compiles, but it does not give the digits.
package main

import "fmt"

func main() {
	seat := 65
	fmt.Println("seat " + string(seat))
}

from session import run

# string(n) compiles and runs, and go vet explains what it really does.
run(
    """
go run stringint.go
go vet stringint.go
""",
    expect_failure=["go vet stringint.go"],
)

$ go run stringint.go
seat A
$ go vet stringint.go
stringint.go:8:24: conversion from int to string yields a string of one rune, not a string of digits
[exit status 1]

A string holds bytes, and a bool holds only true or false

A Go string is a sequence of bytes that never changes once it exists. A string literal holds its text as UTF-8UTF-8: The encoding of Go source code and string literals: each Unicode character takes one to four bytes, so 'A' takes one byte and '₹' three. len of a string counts these bytes., where ‘€’ takes three bytes, and len counts bytes:

// strings_bools.go: a string is a sequence of bytes; a bool is true or false.
package main

import (
	"fmt"
	"strconv"
)

func main() {
	price := "€1999"
	fmt.Println(len(price), "bytes") // € takes 3 bytes in UTF-8
	fmt.Println(price[0], price[3], string(price[3]))
	fmt.Println(price + " with tax") // + makes a new string

	paid := len(price) > 0 // a comparison gives a bool
	fmt.Println(paid, !paid, paid && false)
	ok, err := strconv.ParseBool("yes")
	fmt.Println(ok, err)
}

7 bytes
226 49 1
€1999 with tax
true false false
false strconv.ParseBool: parsing "yes": invalid syntax

“€1999” has length 7, not 5. Indexing gives bytes: price[0] is 226, the first byte of ‘€’, and price[3] is 49, the digit 1. + builds a new string, and price[0] = 'R' does not compile, because a string’s bytes cannot be assigned.

A bool is true or false and nothing else. Comparisons produce one, and !, && and || combine them. No number stands in for a bool, so if count {} with an int does not compile. strconv.ParseBool reads “true”, “false”, 1, 0 and a few short forms, and in the run it refused “yes”.

Overflow, division and remainder, reproduced Pro: opens with a Pro, Premium or Ultimate pass

Money without float drift: cents, rounding and a fair split Pro: opens with a Pro, Premium or Ultimate pass

Practise

This self-check covers number types, conversions, strings and bools. The session starts where you have been least sure, and a wrong choice tells you what it misses:

Interview questions

Warm-up (fresher): Is int the same type as int64 on a 64-bit machine?

No. They have the same size there, but they are different types, so an expression that mixes them does not compile until one side is converted. The size of int belongs to the platform, 32 or 64 bits, while int64 is 64 bits everywhere, so use int64 when the width matters.

Three longer questions of the module bank build on this lesson:

Key takeaways

• Every number type has a fixed size: int is 64 bits on 64-bit platforms, byte is uint8 and rune is int32.
• Go converts between types only where you write a conversion, and a float converts to an integer by dropping the fraction toward zero.
• strconv converts between numbers and text; string(n) gives a character, which go vet reports.
• A string is a sequence of bytes that cannot change, len counts bytes, and a bool is only true or false.