Типы данных

Типы данных определяют виды значений, которые сохраняются определенными переменными при написании программы. Типы данных также помогают определить операции (сложение, вычитание и т.п.), которые можно выполнять с использованием данных.

Как отмечалось ранее в данном руководстве, Go — это язык программирования со статической типизацией. Это означает, что переменные всегда имеют определенный тип и этот тип нельзя изменить.

Пример:

package main
import "fmt"

func main() {
    var name string = "Ivan"
    fmt.Println(name)   // Ivan

    name = 25           // На этом этапе программа уже будет "ругаться"
    fmt.Println(name)   // Вывод: cannot use 25 (untyped int constant) as string value in assignment
}

Предложение cannot use 25 (untyped int constant) as string value in assignment означает, что мы не можем присвоить значение 25 в качестве строкового значения (string) при инициализации. Это связано с тем, что значение 25 имеет другой тип данных (int - сокращенное от integer (целое число)).

Числа

В Go есть несколько различных типов данных для представления чисел. В данном руководстве мы разделим числа на два различных класса: целые числа (int) и числа с плавающей точкой (float).

Целые числа

Целые числа — это числа без дробной части. Наша система строится на 10 различных цифрах (от 0 до 9). В Go существуют следующие типы целых чисел: uint8, uint16, uint32, uint64, int8, int16, int32 и int64. 8, 16, 32 и 64 говорит нам, сколько бит использует каждый тип. uint означает «unsigned integer» (беззнаковое целое). Беззнаковое целое может принимать только положительные значения (или ноль), в то время как int означает «signed integer» (знаковое целое).

Тип данных	Значение аббреваитуры	Диапазон
uint8	Беззнаковые 8-битные целые числа	от 0 до 255
uint16	Беззнаковые 16-битные целые числа	от 0 до 65535
uint32	Беззнаковые 32-битные целые числа	от 0 до 4294967295
uint64	Беззнаковые 64-битные целые числа	от 0 до 18446744073709551615
int8	Знаковые 8-битные целые числа	от -128 до 127
int16	Знаковые 16-битные целые числа	от -32768 до 32767
int32	Знаковые 32-битные целые числа	от -2147483648 до 2147483647
int64	Знаковые 64-битные целые числа	от -9223372036854775808 до 9223372036854775807

Стоит отметить типы int и uint. Они имеют наиболее эффективный размер для определенной платформы (32 или 64 бита):

int - представляет целое число со знаком, которое в зависимости от платформы может занимать либо 4 байта, либо 8 байт. То есть соответствовать либо int32, либо int64.
uint - представляет целое число только без знака, которое, аналогично типу int, в зависимости от платформы может занимать либо 4 байта, либо 8 байт. То есть соответствовать либо uint32, либо uint64.

Также в дополнение к этому существуют два типа-псевдонима: byte (то же самое, что uint8) и rune (то же самое, что int32). Байты очень распространенная единица измерения в компьютерах (1 байт = 8 бит, 1024 байта = 1 килобайт, 1024 килобайта = 1 мегабайт и т.д.), и именно поэтому тип byte в Go часто используется для определения других типов.

Примеры определения переменных, которые представляют целочисленные типы:

var a int8 = -1
var b uint8 = 2
var c byte = 3      // byte - синоним типа uint8
var d int16 = -4
var f uint16 = 5
var g int32 = -6
var h rune = -7     // rune - синоним типа int32
var j uint32 = 8
var k int64 = -9
var l uint64 = 10

var m int = -1000
var n uint = 1000

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

Числа с плавающей точкой — это числа, которые содержат вещественную часть (вещественные числа). Ярким представителем данного типа является число $\pi \approx 3.14159$ . Для представления дробных чисел есть два типа:

float32 — представляет собой число с плавающей точкой от 1.4 * 10 $^{-45}$ до 3.3 * 10 $^{38}$ . Занимает в памяти 32 бита (4 байта)
float64 — представляет собой число с плавающей точной от 4.9 * 10 $^{-324}$ до 1.8 * 10 $^{308}$ . Занимает в памяти 64 бита (8 байт). По умолчанию присваивается именно float64

Примеры использования float32 и float64:

var f float32 = 10.1
var g float32 = 7.5
var h float32 = 4.9

var d float64 = 2.28
var pi float64 = 3.14
var e float64 = 2.718

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

В Golang также существуют комплексные числа как отдельный тип данных:

complex64 — комплксное число, в которой вещественная и мнимая части представляют числа float32
complex128 — комплексное число, где вещественная и мнимая части представляют числа float64

Примеры переменных с типом complex64 и complex128:

var z complex64 = 1+2i
var l complex128 = 3+4i

Тип bool

Тип bool или логический тип может иметь значение true (истина) или false (ложь). Переменная такого типа будет знаимать только один байт. С этим типом часто используются три логических оператора:

Оператор	Значение
&&	И
ll	ИЛИ
!	НЕ

! (НЕ - операция отрицания). Инвертирует значение. Если операнд равен true, то возвращает false, иначе возвращает true. Пример:

var a bool = true
var b bool = !a // false
var c bool = !b // true

&& (И - конъюкция, логическое умножение). Возвращает true, если оба операнда не равны false. Возвращает false, если хотя бы один операнд равен false. Пример:

var b bool = 4 > 3 && 6 > 8  // flase
var c bool = 4 > 3 && 6 > 5  // true

|| (ИЛИ - дизъюнкция, логическое сложение). Возвращает true, если хотя бы один операнд не равен false. Возвращает false, если оба операнда равны false. Пример:

var d bool = 2 > 3 || 1 > 2  // false
var e bool = 2 > 1 || 3 > 4  // true

Примечание от автора: если вы плохо знакомы с основами математической логики, то настоятельно рекомендую ознакомиться с данной статьей.

Тип строка

В теме Переменные мы уже косвенно затрагивали тип данных строка. Как вы уже знаете, строки представлены типом string. Литеральные значения, помещенные в кавычки относятся имеено к данному типу. Следующие строки кода равнозначны:

cake := "cake"
var cake = "cake"
var cake string = "cake"

При объявлении переменной без указанного значения она будет инициализирована с нулевым значением, а нулевые значения типа string являются пустые кавычки (""):

var fool string
fmt.Println(fool) // ""

Кстати, если говорить о предыдущих изученных типах(int, float, bool), то картина будет выглядеть следующим образом:

var numOne int
var numTwo float64
var boo bool

fmt.Println(numOne, numTwo, boo) // 0 0 false

Т.е. из вышеуказанного примера стоит обратить внимание на то, что у переменной с типом данных bool по умолчанию будет значение false.

Escape-последовательности

Помимо обычных символов строка может содержать специальные последовательности (или escape-последовательности), которые всегда начинаются с обратного слеша \. Таблица с наиболее часто используемыми escape-последовательностями представлена ниже:

Escape-последовательность	Описание
\n	переход на новую строку
\t	табуляция
\"	двойная кавычка внутри строк
\\	обратный слеш