Типы данных: числа

Основной целочисленный тип в Go — int. Когда вы пишете x := 42, компилятор создаёт именно int, если правая часть — целое число без явного типа. На большинстве платформ это 64-битное знаковое целое с диапазоном примерно от -9,2 млрд миллионов до +9,2 млрд миллионов — для счётчиков, длин массивов и повседневной арифметики хватает с запасом.

Но int — не единственный вариант. Есть семейство фиксированных размеров: int8 (от -128 до 127), int16, int32, int64 — и их беззнаковые братья uint, uint8, uint16, uint32, uint64, которые принимают только неотрицательные значения. Зачем они нужны? Когда размер важен: uint8 (у него есть псевдоним byte) лежит в основе работы с байтами, int64 встречается в метках времени и базах данных, int32 — в протоколах обмена.

Практическое правило: по умолчанию пишите int и не думайте о размере. Явные типы берите тогда, когда формат данных диктует их — сетевой протокол, бинарный файл, стыковка с базой. Для новичка выбор «int для всего целого» — не лень, а идиома.

Дробные числа в Go живут в двух типах: float64 и float32. Если тип не указан, pi := 3.14 создаёт float64 — и это правильный выбор по умолчанию. float64 хранит около 15-16 значащих цифр и покрывает почти все бытовые задачи: физика, координаты, статистика. float32 экономит память (4 байта вместо 8), но даёт лишь около 7 цифр точности — его берут для больших массивов данных, графики и машинного обучения, где объём важнее точности.

Важно понимать: float — это двоичное представление дроби, а не десятичное. Числа вроде 0.1 точно не представляются, из-за чего 0.1 + 0.2 оказывается 0.30000000000000004. Это не баг Go, а свойство IEEE 754 — так работают float в любом современном языке. Именно поэтому дробные деньги в финансах хранят в целых копейках, а не во float.

Пара синтаксических мелочей: запись 3. (три и точка) легальна и равна 3.0, а экспонента пишется через e: 1e9, 2.5e-3.

Самая частая ловушка новичка в Go — деление целых чисел. Оператор / для двух целых типов выполняет целочисленное деление: дробная часть отбрасывается без округления. 7 / 2 — это 3, 1 / 2 — это 0, -7 / 2 — это -3 (усечение к нулю, а не в меньшую сторону).

Хотите честное деление? Хотя бы один операнд должен быть float: 7.0 / 2 даст 3.5. Обычно это делают явным преобразованием: float64(x) / 2.

Рядом с / живёт оператор остатка %: 7 % 2 — это 1. Он незаменим для проверки чётности (n % 2 == 0), циклических индексов (i % len(list)) и разбиения на страницы. Запомните связку: деление целых усекает, остаток возвращает то, что «не поделилось».

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

Go не выполняет неявных преобразований между числовыми типами. Сложить int и float64 напрямую нельзя — программа не скомпилируется с ошибкой «mismatched types int and float64». Преобразование пишется явно, как вызов функции: float64(x), int(pi), byte(n).

Это может раздражать после JavaScript, где всё складывается со всем. Но у строгого подхода есть цена и выгода: цена — чуть больше печатания; выгода — в коде никогда не происходит «магических» потерь данных. Посмотрев на строку total := float64(count) * price, вы точно знаете, где случилось преобразование.

При преобразовании вниз данные теряются по правилам усечения. int(99.99) — это 99: дробная часть отбрасывается, никакого округления. Для честного округления используется math.Round из одноимённого пакета. А byte(300) даст 44: 300 не помещается в диапазон 0-255, и лишние старшие биты отсекаются (300 - 256 = 44).

Каждый целочисленный тип ограничен. У int8 диапазон от -128 до 127 — и добавление единицы к 127 в настоящем Go не вызывает ни ошибки, ни исключения: значение «заворачивается» и становится -128. Такой инцидент называется переполнением, и компилятор его не ловит — переменная тихо содержит бессмысленное число.

Переполнение бьёт по конкретным местам: вычитание в счётчиках обратного отсчёта, умножение больших чисел, суммы по длинным массивам. Классика — неаккуратный uint: он не может быть отрицательным, поэтому u - 1 при u = 0 даёт максимальное значение типа, а не -1. История программирования полна уязвимостей, построенных на этом эффекте.

Как защищаться? Первое: работайте с int — у него диапазон настолько велик, что переполнение в учебных задачах недостижимо. Второе: если данные приходят извне и теоретически велики, проверяйте границы перед арифметикой. Третье: для по-настоящему больших чисел в стандартной библиотеке есть math/big — произвольная точность ценой скорости.

Два типа из этого урока заслуживают отдельного знакомства, потому что они притворяются не числами. byte — это псевдоним uint8, то есть число от 0 до 255. rune — псевдоним int32, число-код символа в таблице Unicode. Технически это целые числа; семантически они описывают байт и символ.

Псевдоним здесь означает дословно: byte и uint8 — один и тот же тип, можно даже присваивать друг другу без преобразований. То же верно для rune и int32.

Зачем знать это уже сейчас? Во-первых, чтобы не удивляться, когда строковый индекс возвращает число: s[0] у строки — это byte, то есть 65 для «A». Во-вторых, чтобы понимать сообщения об ошибках вроде «cannot use rune (variable of type rune) as int32». А подробный разговор о строках, байтах и рунах — тема следующего урока, где мы будем резать строки и считать кириллические символы.