Типы данных в Golang: int, float64, string, bool, byte, rune

Базовые типы Go это числа, булевы значения и строки. У каждой переменной ровно один тип, зафиксированный на этапе компиляции, и Go никогда не преобразует типы за вас. %T печатает тип любого значения:

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)
}

Обратите внимание: 'G' печатается как 71 с типом int32. Символ в одинарных кавычках это руна, то есть число (кодовая точка Unicode). rune это псевдоним int32 (тот же тип под вторым именем), поэтому %T сообщает int32. Точно так же byte показывается как uint8.

Целые числа

По умолчанию используйте int. len() возвращает int, индексы слайсов имеют тип int, счётчики циклов тоже int. На любой 64-битной платформе int занимает 64 бита. Типы с фиксированным размером нужны, когда размер входит в контракт: int32 в бинарном формате файла, uint8 для сырых байтов, int64 для Unix-времени в наносекундах.

Не используйте беззнаковые типы для величин, которые «не могут быть отрицательными», например для количества. Вычитание ниже нуля даёт огромное число, а не отрицательное, которое можно было бы поймать.

Пределы и переполнение

В пакете math есть константа для каждого предела. Во время выполнения переполнение целочисленной арифметики молча заворачивается по кругу:

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)
}

Ни паники, ни ошибки: 127 + 1 превращается в -128. На этапе компиляции проверяются только константные выражения (var b int8 = 128 не скомпилируется). Если в ваших данных переполнение возможно, проверяйте перед операцией или используйте math/big.

Целочисленные литералы

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

Числа с плавающей точкой

Литерал с десятичной точкой или экспонентой (2.5, 1e6) по умолчанию имеет тип float64, и пакет math принимает и возвращает float64. Используйте его, если только память в большом массиве не критична.

Числа с плавающей точкой двоичные, поэтому большинство десятичных дробей хранится приближённо:

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())
}

Отсюда два правила. Никогда не сравнивайте float через == после арифметики. И никогда не храните деньги во float: используйте целое число копеек или библиотеку десятичных чисел.

Деление float на ноль даёт +Inf, -Inf или NaN вместо паники. Деление целого на ноль вызывает панику во время выполнения (runtime error: integer divide by zero), а константный нулевой делитель это ошибка компиляции.

Булевы значения

bool хранит true или false, нулевое значение false. Go не считает числа, пустые строки или nil булевыми значениями. if count {} это ошибка компиляции; пишите if count > 0 {}. Операторы: &&, || и !, причём && и || вычисляются по короткой схеме.

Строки

string это неизменяемая последовательность байтов, обычно текст в UTF-8. len(s) считает байты, а не символы:

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)
}

é занимает в UTF-8 два байта, поэтому len сообщает 6 для пяти символов. Строки в двойных кавычках обрабатывают escape-последовательности вроде \n; сырые строки в обратных кавычках их не обрабатывают и могут занимать несколько строк. Пакет strings разобран на странице о строках, а UTF-8 подробно описан на странице о рунах и байтах.

byte и rune

Это псевдонимы, а не новые типы: byte и uint8 взаимозаменяемы без преобразования. Имена лишь говорят, что означает число.

Комплексные числа

В Go есть встроенные комплексные типы complex64 и complex128, функции real, imag и пакет math/cmplx:

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))
}

Они нужны немногим программам, но в обработке сигналов и некоторых численных задачах без них не обойтись.

Составные и ссылочные типы

Базовые типы складываются в составные. У каждого есть своя страница:

any это псевдоним interface{} (с Go 1.18), он может хранить значение любого типа.

Именованные типы

Можно определить новый тип на основе существующего. Представление у него то же, но это отдельный тип, и у него могут быть методы:

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

В этой строгости и смысл: UserID нельзя случайно передать туда, где ожидается OrderID. Если преобразование задумано, пишите его явно: float64(t). Правила описаны на странице о преобразовании типов, там же функции strconv для перехода между числами и строками.

Нулевые значения

У каждого типа есть нулевое значение, которое хранит переменная, пока вы ничего не присвоили: 0 для чисел, false для bool, "" для строк и nil для указателей, слайсов, мап, каналов, функций и интерфейсов. Неинициализированных переменных в Go нет.