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

Краткое описание

В этом уроке разбираем фундаментальное понятие переменной и знакомимся с системой числовых типов в Go. Изучаем целые числа со знаком и без, числа с плавающей точкой, альясы типов и архитектурно-зависимые типы.

Ключевые концепции

Что такое переменная

Переменная — это именованная область в оперативной памяти, которая хранит значение определённого типа. Go является строго типизированным языком, что означает: при объявлении переменной нужно явно или неявно указать её тип.

Строгая типизация

В Go каждая переменная имеет конкретный тип, который определяет:

  • Какие значения можно хранить
  • Сколько памяти выделяется
  • Какие операции разрешены

Числовые типы в Go

Целые числа без знака (Unsigned Integers)

Беззнаковые целые числа — хранят только неотрицательные значения:

Тип Размер Диапазон значений
uint8 8 бит (1 байт) 0 до 255
uint16 16 бит (2 байта) 0 до 65 535
uint32 32 бита (4 байта) 0 до 4 294 967 295
uint64 64 бита (8 байт) 0 до 18 446 744 073 709 551 615

Когда использовать: работа с данными, которые по определению не могут быть отрицательными (например, размер файла, количество элементов).

Целые числа со знаком (Signed Integers)

Знаковые целые числа — хранят как положительные, так и отрицательные значения:

Тип Размер Диапазон значений
int8 8 бит (1 байт) -128 до 127
int16 16 бит (2 байта) -32 768 до 32 767
int32 32 бита (4 байта) -2 147 483 648 до 2 147 483 647
int64 64 бита (8 байт) -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807

Применение в реальных проектах: В большинстве случаев достаточно использовать int32 или просто int.

Числа с плавающей точкой (Floating-Point)

Для хранения дробных чисел (с запятой) используются типы float:

  • float32 — 32-битное число (4 байта), стандарт IEEE 754
  • float64 — 64-битное число (8 байт), стандарт IEEE 754
var price float32 = 0.25
var pi float64 = 3.14159265359

Важно: float64 обеспечивает большую точность, чем float32, и используется по умолчанию для дробных литералов.

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

Go поддерживает комплексные числа “из коробки”:

  • complex64 — комплексное число с float32 компонентами
  • complex128 — комплексное число с float64 компонентами

В академических и большинстве бизнес-задач используются редко, но поддержка есть на уровне языка.

Альясы (псевдонимы типов)

Go предоставляет удобные альясы для часто используемых типов:

byte 

byte  // альяс для uint8

Используется для работы с сырыми данными, байтами в массивах, сетевыми пакетами.

rune 

rune  // альяс для int32

Представляет Unicode code point (символ). Используется при работе с текстом и строками.

Архитектурно-зависимые типы

int и uint

Специальные типы, размер которых зависит от архитектуры процессора:

int   // 32 бита на 32-разрядной системе
      // 64 бита на 64-разрядной системе

uint  // аналогично для беззнакового

На 32-битной архитектуре:

  • int эквивалентен int32
  • uint эквивалентен uint32

На 64-битной архитектуре:

  • int эквивалентен int64
  • uint эквивалентен uint64

Рекомендация: Для большинства задач используйте просто int — компилятор сам выберет оптимальный размер.

uintptr 

uintptr  // беззнаковое целое, достаточное для хранения указателя

Используется в low-level программировании при работе с указателями и небезопасными операциями.

Практика

Соотношение бит и байт

1 байт = 8 бит

Примеры:

  • int32 — 32 бита = 4 байта
  • float64 — 64 бита = 8 байт
  • uint16 — 16 бит = 2 байта

Выбор типа для конкретных задач

Для счётчиков и индексов:

var count int  // рекомендуется

Для финансовых расчётов:

var price float64  // для точности

Для работы с байтами (файлы, сеть):

var data []byte  // массив байтов

Для работы с символами:

var char rune  // один Unicode символ

Важные моменты

1. Явное приведение типов В Go нет автоматического приведения между числовыми типами. Даже int32 и int требуют явной конвертации:

var a int32 = 100
var b int = int(a)  // явное преобразование обязательно

2. Два’s complement Знаковые целые числа представлены в формате дополнительного кода (two’s complement), что обеспечивает эффективные арифметические операции.

3. Переполнение Go не выполняет проверку переполнения на уровне runtime. При превышении максимального значения происходит wraparound (циклический переход):

var x uint8 = 255
x = x + 1  // x станет 0

4. Значения по умолчанию Неинициализированные числовые переменные имеют нулевое значение:

  • Целые числа: 0
  • Числа с плавающей точкой: 0.0

5. Размер имеет значение Выбирайте тип в зависимости от диапазона значений. Использование int64 вместо int8 расходует в 8 раз больше памяти — в высоконагруженных системах это критично.

Что запомнить

  • Переменная = именованная область памяти с типом
  • Go строго типизирован — тип всегда известен на этапе компиляции
  • Беззнаковые: uint8, uint16, uint32, uint64 (только ≥ 0)
  • Знаковые: int8, int16, int32, int64 (включая отрицательные)
  • Дробные: float32, float64
  • Альясы: byte = uint8, rune = int32
  • int/uint — размер зависит от архитектуры (32 или 64 бита)
  • Для большинства задач используйте int, float64
  • Явное приведение типов обязательно — автоматической конвертации нет
  • 1 байт = 8 бит