Краткий ответ

Нетипизированная константа сохраняет значение и категорию, но не получает обычный тип до появления контекста. При присваивании или передаче аргумента Go выбирает тип назначения, если значение в нём представимо; при отсутствии такого контекста используется тип по умолчанию, например int для целой константы.

package main

import "fmt"

func take(x int8) {}

func main() {
	const n = 100
	var a int8 = n
	take(n)
	b := n
	fmt.Printf("%T %T %T
", a, b, any(n))
}

Здесь n подходит для int8 в присваивании и вызове take, а b получает тип int. При преобразовании к any константа также получает тип по умолчанию — int.

Исторический контекст

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

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

Постановка проблемы

Одинаковая запись константы может участвовать в операциях с разными типами. Неверно считать, что const n = 100 сразу означает значение типа int: до появления контекста n остаётся нетипизированной константой.

Ошибка возникает, если значение нельзя представить в требуемом типе. Например, присваивание слишком большой целой константы переменной типа int8 завершается ошибкой компиляции, а не неявным переполнением.

Подробное решение

У нетипизированной константы есть числовая категория: целая, вещественная, мнимая или строковая. Пока контекст не требует конкретного типа, компилятор хранит её значение с высокой точностью, а не ограничивает его сразу возможностями int, float64 или другого типа.

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

Если явного контекста нет, используется тип по умолчанию. Для нетипизированных целых это int, для нетипизированных вещественных — float64, для мнимых — complex128, для строк — string, для логических значений — bool.

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

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

Ситуация из практики

В библиотеке объявили константу размера буфера без явного типа. Один вызов передаёт её функции, принимающей int, другой — функции, принимающей int64. Если константа представима в обоих типах, оба вызова корректны, а сама константа не ограничивает интерфейс библиотеки преждевременно.

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

Практичное решение — оставлять константу нетипизированной, если она является абстрактным числовым параметром и должна применяться в разных типах. Явный тип стоит задавать, когда тип является частью контракта API или необходимо намеренно ограничить допустимые операции. Это сохраняет переносимость и предотвращает неявное получение неподходящего типа в коротком объявлении.

Что кандидаты часто упускают

1. Получит ли нетипизированная константа тип параметра при передаче в функцию?

Да, в контексте вызова она приводится к типу соответствующего параметра, если значение представимо. Это не означает, что сама константа навсегда становится таким типом: в другом контексте она может быть использована с другим типом.

2. Что произойдёт при присваивании нетипизированной константы переменной через короткое объявление?

Будет выбран тип по умолчанию для категории константы. Поэтому целая константа в x := ... обычно создаёт переменную типа int, даже если в другом месте та же константа успешно присваивается переменной типа int64.

3. Почему очень большая константа может участвовать в вычислении, но не присваиваться переменной?

Пока значение остаётся нетипизированным, компилятор вычисляет константное выражение с высокой точностью. При присваивании конкретному типу появляется ограничение его диапазона и представимости; если оно нарушено, компиляция завершается ошибкой. Автоматического runtime-переполнения для такого константного присваивания нет.