Типизация и преобразование числовых данных

Проблема строгих типов на практике

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

Эта строгость — осознанное проектное решение, которое предотвращает трудноуловимые ошибки, возможные в языках с неявным приведением типов. Но как же тогда быть с литералами? Почему мы можем написать x := 10 / 3.0, но не можем сделать то же самое с переменными a := 10 и b := 3.0? Ответ кроется в особом статусе констант.

Константы: типизированные и нетипизированные

В Go константы, в отличие от переменных, могут быть "нетипизированными". Это не значит, что у них нет типа вообще; это значит, что их тип еще не зафиксирован в строгой системе типов Go. Они существуют в своего рода "идеальном" пространстве значений высокой точности.

Прочтите вводную часть статьи Роба Пайка, одного из создателей Go, где он объясняет мотивацию такого дизайна.

Самый простой способ понять разницу между типизированными и нетипизированными константами — на примере строк.

• const typedHello string = "Hello" — это типизированная константа. Она имеет конкретный тип string и подчиняется всем правилам. Ее нельзя присвоить переменной другого типа, даже если он основан на строке (type MyString string).
• const untypedHello = "Hello" — это нетипизированная константа. У нее еще нет фиксированного типа Go. Это просто текстовое значение, которое может быть присвоено любой переменной, совместимой со строками.

Изучите этот ключевой концепт на примере строк в следующей части статьи.

Тип по умолчанию (Default Type)

Когда же нетипизированная константа обретает свой тип? Это происходит только тогда, когда контекст этого требует. Например, в объявлении x := 100, переменная x должна получить конкретный тип. В этом случае нетипизированная константа 100 передает ей свой тип по умолчанию.

Тип по умолчанию определяется синтаксисом литерала:

• Целочисленные литералы (например, 10, 0xFF) имеют тип по умолчанию int.
• Литералы с плавающей точкой (например, 3.14, 1e6) имеют тип float64.
• Символьные литералы в одинарных кавычках (например, 'a') имеют тип rune (синоним int32).
• Логические литералы true и false имеют тип bool.

Мощь нетипизированных констант

Такой дизайн дает два огромных преимущества: гибкость и точность.

1. Гибкость: Нетипизированная числовая константа может быть использована везде, где ожидается числовой тип, если ее значение укладывается в диапазон этого типа.

   • var i int8 = 127 — OK, 127 — нетипизированная константа, помещается в int8.
   • var f float32 = 127 — OK, 127 может быть представлена как float32.
   • var i int8 = 128 — Ошибка компиляции! Значение 128 выходит за пределы диапазона int8 (от -128 до 127).

2. Точность: Числовые константы в Go существуют в пространстве чисел с произвольной точностью. Они не ограничены 64-битными float64 или int64. Вычисления с ними производятся компилятором с максимальной точностью, и только конечный результат, при присвоении переменной, усекается до нужного типа.

Это позволяет писать такой код:

const secondsInDay = 24 * 60 * 60 // Вычисляется на этапе компиляции

const hugeNumber = 1e1000 // Это валидная константа...
// var x = hugeNumber // ...но она не поместится ни в один стандартный тип
var y = hugeNumber / 1e999 // А так можно! Результат (10.0) помещается в float64

Этот подход объединяет числовые литералы всех видов (целые, дробные, комплексные) в единое пространство, где они ведут себя просто как числа.

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

Явные преобразования типов

Гибкость нетипизированных констант заканчивается там, где начинаются переменные. Как только значение присвоено переменной, его тип строго фиксирован. Для выполнения операций между переменными разных числовых типов необходимо использовать явное преобразование типа в форме T(v), где T — целевой тип, а v — значение.

var a int = 10
var b int64 = 20

// sum := a + b // Ошибка: mismatched types int and int64

// Правильно:
sum := int64(a) + b 
// или
sum2 := a + int(b)

Преобразование возможно только между совместимыми типами. Например, можно преобразовать int в float64, но нельзя потерять дробную часть при преобразовании float64 в int без явного намерения.

В качестве практического примера, посмотрите, как выполняется преобразование между int и int64 в следующем видеофрагменте.

Итоги

Давайте подведем итог. Сегодня мы разобрали один из самых элегантных аспектов системы типов Go.

• Нетипизированные константы — это "идеальные" значения (числа, строки, булевы), которые еще не имеют конкретного типа Go. Они существуют с произвольной точностью.
• Они получают тип по умолчанию (int, float64 и т.д.) только тогда, когда контекст (например, присваивание переменной :=) этого требует.
• Эта гибкость позволяет писать естественный код (например, math.Sqrt(2)) без лишних преобразований типов. Компилятор сам подставляет нужный тип для нетипизированной константы, если значение в него помещается.
• Как только значение оказывается в переменной, его тип строго фиксирован. Для операций между переменными разных, но совместимых типов, необходимо явное преобразование T(value).

Теперь вы понимаете тонкий баланс между строгостью и гибкостью в Go. Эта модель позволяет писать одновременно безопасный и лаконичный код.

На следующем уроке мы вернемся к оператору := и обсудим его применение в разных областях видимости, а также разберем распространенную ошибку, известную как "затенение переменных" (variable shadowing).