Базовые типы

В уроке о переменных переменная была коробкой с наклейкой. У каждой такой коробки есть форма. В коробку для яиц не положишь книгу, а в футляр для очков — кастрюлю. В Go форму коробки задаёт тип.

Две переменные ниже печатаются одинаково, хотя хранят значения разных типов:

package main

import "fmt"

func main() {
    a := 3
    b := 3.0
    fmt.Println(a, b)           // 3 3
    fmt.Printf("%T %T\n", a, b) // int float64
}

Тип определяет, какие значения хранит переменная и какие операции с ней разрешены. Давайте разберём программу по строкам:

1. a := 3 — a получает тип int, потому что 3 — целое число.
2. b := 3.0 — b получает тип float64 из-за точки в 3.0.
3. fmt.Println(a, b) печатает 3 3: дробное 3.0 выводится как 3.
4. fmt.Printf("%T %T\n", a, b) печатает типы, int float64, и только здесь видна разница.

Снаружи коробки выглядят одинаково, а форма у них разная.

Четыре основных типа

Давайте разберём каждый тип отдельно.

int — целые числа

int хранит целое число без дробной части: 42, -7, 0. Число без точки в коде компилятор делает int, поэтому a := 3 — целая переменная.

В int хранят то, что считают поштучно: количество, номер, счёт. Если из целого числа нужна дробная переменная, тип пишут явно: var price float64 = 3.

float64 — дробные числа

float64 хранит число с дробной частью: 3.14, 2.0. Точка в записи делает значение дробным, даже если после неё ноль: 3.0 — это float64.

В float64 хранят то, что измеряют: цену, вес, температуру. Ловушку вы уже видели: fmt.Println печатает 3.0 как 3, и тип по выводу не угадать. Тогда помогает %T.

string — текст

string хранит текст, и его пишут в двойных кавычках: "Go". Строки складываются тем же оператором +, что и числа: "Go" + "pher" даёт "Gopher".

Тип определяет, что делает оператор. Для чисел + считает сумму, а для строк склеивает их.

Ещё встречается тип rune: целое число, которым Go описывает один символ строки. Его пишут в одинарных кавычках. С ним связана частая ошибка в конце урока.

bool — истина или ложь

У bool всего два значения: true и false. В нём хранят ответ «да» или «нет»: готов ли заказ, включён ли звук.

В Go bool — не число. Запись var ok bool = 1 не скомпилируется: cannot use 1 (untyped int constant) as bool value in variable declaration.

Тип выбирается один раз

Тип переменной выбирается один раз, при объявлении, и потом не меняется. После a := 3 переменная a хранит только целые числа.

Присваивание a = 2.5 не скомпилируется: cannot use 2.5 (untyped float constant) as int value in assignment (truncated). Слово truncated значит, что дробная часть потерялась бы, и компилятор этого не допускает.

Здесь картинка с коробками перестаёт работать. Настоящую коробку можно попробовать набить чем-то чужим, и иногда это даже получится. В Go так не выйдет: компилятор проверяет форму каждой коробки ещё до запуска программы.

Форматированный вывод

fmt.Printf печатает текст по шаблону — форматной строке. Printf заменяет каждый знак % с буквой в шаблоне очередным аргументом. В этом уроке нужны три части шаблона:

• %v печатает значение так же, как fmt.Println;
• %T печатает тип значения;
• \n переводит строку: в отличие от Println, Printf не делает этого сам.

%T помогает, когда непонятно, какой тип компилятор взял из значения.

name := "Go"
ready := true
fmt.Printf("%v %v\n", name, ready) // Go true
fmt.Printf("%T %T\n", name, ready) // string bool

Давайте разберём пример по строкам:

1. name := "Go" — строка, потому что значение в двойных кавычках.
2. ready := true — значение типа bool.
3. Первый Printf подставляет вместо двух %v значения name и ready и печатает Go true.
4. Второй Printf подставляет их типы и печатает string bool.

В конце каждой строки вывода стоит перевод строки из \n.

Частая ошибка

Строку записали в одинарных кавычках, как в некоторых других языках:

s := 'Go' // ✗
fmt.Println(s)

more than one character in rune literal

В Go одинарные кавычки задают один символ — значение типа rune, а не строку. Текст пишут в двойных кавычках: s := "Go".

Главное

• Тип задаёт, какие значения хранит переменная и какие операции с ней разрешены; после объявления он не меняется.
• Основные типы — int, float64, string и bool; из 3 получается int, а из 3.0 — float64.
• fmt.Printf печатает по шаблону: %v — значение, %T — тип, а \n переводит строку.
• Строки пишут в двойных кавычках, а одинарные задают один символ типа rune.