Ошибка	Последствие
Считать, что `uint` при переполнении паникует или насыщается	Тихое оборачивание по модулю 2^n; бесконечный цикл или неверный счётчик
Вычитать больший `uint` из меньшего, ожидая отрицательного результата	Получается огромное положительное число — нет промежуточного «минуса»
Думать, что знаковый тип хранит знак отдельным флаг-битом	Неверная модель дополнительного кода; ошибка в расчёте диапазона
Считать `int` всегда 32-битным или всегда 64-битным	Несовпадение размеров между платформами; битый бинарный формат
Брать максимум `int64` как 2^64−1 или 2^63	Это диапазон `uint64` или ошибка на единицу; верно 2^63−1
Писать `float64(a / b)` вместо `float64(a) / float64(b)`	Деление усекает в `int` ДО приведения — точность теряется
Делить на ноль без проверки длины среза	`sum / len(s)` на пустом срезе паникует `integer divide by zero`
Считать, что `s[0] = 'R'` — это runtime-паника	Это ошибка компиляции — `string` не поддерживает запись по индексу
Считать `len(s)` числом символов строки	`len` считает байты; многобайтовый символ UTF-8 считается дважды и больше
Забыть, что строка с `_` тоже потребляет значение `iota`	Сдвиг всех последующих констант на единицу
Путать `:=` во вложенном блоке с присваиванием	Заводит НОВУЮ переменную, затеняя внешнюю — ошибка или значение «теряются»
Ждать, что `break` в `switch` внутри `for` выйдет из цикла	Выходит только из `switch`; цикл продолжает крутиться
Считать копию структуры ссылкой	`b := a` копирует ВСЕ поля; правка `b` не видна в `a`
Принимать встраивание структуры за наследование	Это композиция: нет полиморфизма, своё поле просто затеняет встроенное

intermediate

Values, Constants & Numbers

Go's integer types and overflow, signed and unsigned arithmetic, strings, runes and bytes, iota constants, scopes, and control flow.

go-values

Practice: 10 questions · 3 tasks →

Sections

Contents

Detailed explanation

Values, Constants & Numbers

Go deliberately made its basic values small and predictable — a handful of fixed-width integer types, read-only strings, constants driven by an iota counter. Because of that simplicity they are barely studied: "well, a number is a number, what is there to learn." That is precisely why they produce the quietest and most expensive bugs — the ones that do not fail at build time and surface only in production or in an interview.

There is mechanism under the simple syntax. An integer is a fixed bit layout with specific overflow behaviour, and the width of int depends on the platform and is fixed by the compiler, not chosen at runtime. An unsigned type does not go negative — it wraps around modulo 2^n. A string is an immutable sequence of bytes, and len(s) counts exactly those bytes, not characters. This topic takes values apart layer by layer — from how a single integer is built to the rules for the visibility of names in a package.

Topic map

Signed and unsigned types — two's complement, non-negative uint, and wrap-around modulo 2^n on overflow instead of an error.
Integer sizes — fixed widths of 8/16/32/64 bits and the platform-dependent int whose width is fixed by the implementation, not the runtime.
Integer range — how two's complement splits bits between the negative and positive halves and why the int64 maximum is 2^63−1.
Integer division — integer / truncates toward zero, convert before dividing, and divide-by-zero panics.
String immutability — string is read-only, s[0] = ... does not compile, and mutating a byte goes through []byte with a copy.
Runes vs bytes — len(s) counts bytes, utf8.RuneCountInString counts runes, and range over a string decodes runes.
iota and constants — the iota counter increments per line in a const block (counting _) and resets in a new block.
Scope and visibility — nested scopes from block to universe and cross-package visibility by identifier case.
switch and control flow — switch with no fall-through, fallthrough, switch true, the type switch, and labeled break in a loop.
Structs — a composite type of named fields, value semantics with copying, embedding, methods, and tags.

Common Mistakes and Traps

Mistake	Consequence
Believing `uint` panics or saturates on overflow	Silent wrap-around modulo 2^n; an infinite loop or a wrong counter
Subtracting a larger `uint` from a smaller one expecting a negative result	You get a huge positive number — there is no intermediate "minus"
Thinking a signed type stores the sign in a separate flag bit	Wrong two's-complement model; an error in the range calculation
Treating `int` as always 32-bit or always 64-bit	Size mismatch between platforms; a corrupted binary format
Taking the `int64` maximum as 2^64−1 or 2^63	That is the `uint64` range or an off-by-one; the correct value is 2^63−1
Writing `float64(a / b)` instead of `float64(a) / float64(b)`	Division truncates in `int` BEFORE the cast — precision is lost
Dividing by zero without checking the slice length	`sum / len(s)` on an empty slice panics `integer divide by zero`
Believing `s[0] = 'R'` is a runtime panic	It is a compile error — `string` does not support index assignment
Treating `len(s)` as the number of characters	`len` counts bytes; a multi-byte UTF-8 character counts as two or more
Forgetting that a line with `_` also consumes an `iota` value	All following constants shift by one
Confusing `:=` in a nested block with assignment	It declares a NEW variable shadowing the outer one — an error or value is "lost"
Expecting `break` in a `switch` inside a `for` to leave the loop	It leaves only the `switch`; the loop keeps spinning
Treating a struct copy as a reference	`b := a` copies ALL fields; mutating `b` is not visible in `a`
Mistaking struct embedding for inheritance	It is composition: no polymorphism, an own field simply shadows the embedded one

Interview Relevance

Numbers and values are the warm-up of a Go interview, but they are exactly where the inattentive get filtered out. Interviewers ask not the syntax but the model of behaviour under it: when a type wraps, when division truncates, what len actually counts.

What interviewers check:

The difference between signed and unsigned types — two's complement and wrap-around modulo 2^n.
What integer widths Go provides and what determines the width of int — the implementation and platform, not the runtime.
How to compute the range of int64 and why its maximum is 2^63−1, not 2^63 or 2^64−1.
What integer / does and why float64(a / b) loses precision.
Why string is immutable and what indexing a string returns — a byte, not a character.
How len(s) differs from the rune count and how range over a string decodes runes.
How iota counts (including lines with _) and the rules of name visibility and shadowing in a package.

A typical wrong answer: "an unsigned counter will go negative when you subtract — it is just ordinary arithmetic." That opens the discussion that uint has no "minus": on overflow it wraps around modulo 2^n, and a for i := uint(...); i >= 0; i-- loop never terminates.

Why it matters

Numbers and values in Go look so simple that they are not studied seriously — and that is exactly where the quietest bugs live. An unsigned counter that wraps instead of going negative; integer division that silently truncates; `len(s)` counting bytes instead of characters; a `:=` in a nested block that declares a new variable instead of assigning — none of these are exotica but classic production incidents and interview questions.

Ошибка	Последствие
Считать, что `uint` при переполнении паникует или насыщается	Тихое оборачивание по модулю 2^n; бесконечный цикл или неверный счётчик
Вычитать больший `uint` из меньшего, ожидая отрицательного результата	Получается огромное положительное число — нет промежуточного «минуса»
Думать, что знаковый тип хранит знак отдельным флаг-битом	Неверная модель дополнительного кода; ошибка в расчёте диапазона
Считать `int` всегда 32-битным или всегда 64-битным	Несовпадение размеров между платформами; битый бинарный формат
Брать максимум `int64` как 2^64−1 или 2^63	Это диапазон `uint64` или ошибка на единицу; верно 2^63−1
Писать `float64(a / b)` вместо `float64(a) / float64(b)`	Деление усекает в `int` ДО приведения — точность теряется
Делить на ноль без проверки длины среза	`sum / len(s)` на пустом срезе паникует `integer divide by zero`
Считать, что `s[0] = 'R'` — это runtime-паника	Это ошибка компиляции — `string` не поддерживает запись по индексу
Считать `len(s)` числом символов строки	`len` считает байты; многобайтовый символ UTF-8 считается дважды и больше
Забыть, что строка с `_` тоже потребляет значение `iota`	Сдвиг всех последующих констант на единицу
Путать `:=` во вложенном блоке с присваиванием	Заводит НОВУЮ переменную, затеняя внешнюю — ошибка или значение «теряются»
Ждать, что `break` в `switch` внутри `for` выйдет из цикла	Выходит только из `switch`; цикл продолжает крутиться
Считать копию структуры ссылкой	`b := a` копирует ВСЕ поля; правка `b` не видна в `a`
Принимать встраивание структуры за наследование	Это композиция: нет полиморфизма, своё поле просто затеняет встроенное

intermediate

Values, Constants & Numbers

Go's integer types and overflow, signed and unsigned arithmetic, strings, runes and bytes, iota constants, scopes, and control flow.

go-values

Practice: 10 questions · 3 tasks →

Sections

Contents

Detailed explanation

Values, Constants & Numbers

Topic map

Signed and unsigned types — two's complement, non-negative uint, and wrap-around modulo 2^n on overflow instead of an error.
Integer sizes — fixed widths of 8/16/32/64 bits and the platform-dependent int whose width is fixed by the implementation, not the runtime.
Integer range — how two's complement splits bits between the negative and positive halves and why the int64 maximum is 2^63−1.
Integer division — integer / truncates toward zero, convert before dividing, and divide-by-zero panics.
String immutability — string is read-only, s[0] = ... does not compile, and mutating a byte goes through []byte with a copy.
Runes vs bytes — len(s) counts bytes, utf8.RuneCountInString counts runes, and range over a string decodes runes.
iota and constants — the iota counter increments per line in a const block (counting _) and resets in a new block.
Scope and visibility — nested scopes from block to universe and cross-package visibility by identifier case.
switch and control flow — switch with no fall-through, fallthrough, switch true, the type switch, and labeled break in a loop.
Structs — a composite type of named fields, value semantics with copying, embedding, methods, and tags.

Common Mistakes and Traps

Mistake	Consequence
Believing `uint` panics or saturates on overflow	Silent wrap-around modulo 2^n; an infinite loop or a wrong counter
Subtracting a larger `uint` from a smaller one expecting a negative result	You get a huge positive number — there is no intermediate "minus"
Thinking a signed type stores the sign in a separate flag bit	Wrong two's-complement model; an error in the range calculation
Treating `int` as always 32-bit or always 64-bit	Size mismatch between platforms; a corrupted binary format
Taking the `int64` maximum as 2^64−1 or 2^63	That is the `uint64` range or an off-by-one; the correct value is 2^63−1
Writing `float64(a / b)` instead of `float64(a) / float64(b)`	Division truncates in `int` BEFORE the cast — precision is lost
Dividing by zero without checking the slice length	`sum / len(s)` on an empty slice panics `integer divide by zero`
Believing `s[0] = 'R'` is a runtime panic	It is a compile error — `string` does not support index assignment
Treating `len(s)` as the number of characters	`len` counts bytes; a multi-byte UTF-8 character counts as two or more
Forgetting that a line with `_` also consumes an `iota` value	All following constants shift by one
Confusing `:=` in a nested block with assignment	It declares a NEW variable shadowing the outer one — an error or value is "lost"
Expecting `break` in a `switch` inside a `for` to leave the loop	It leaves only the `switch`; the loop keeps spinning
Treating a struct copy as a reference	`b := a` copies ALL fields; mutating `b` is not visible in `a`
Mistaking struct embedding for inheritance	It is composition: no polymorphism, an own field simply shadows the embedded one

Interview Relevance

What interviewers check:

The difference between signed and unsigned types — two's complement and wrap-around modulo 2^n.
What integer widths Go provides and what determines the width of int — the implementation and platform, not the runtime.
How to compute the range of int64 and why its maximum is 2^63−1, not 2^63 or 2^64−1.
What integer / does and why float64(a / b) loses precision.
Why string is immutable and what indexing a string returns — a byte, not a character.
How len(s) differs from the rune count and how range over a string decodes runes.
How iota counts (including lines with _) and the rules of name visibility and shadowing in a package.

Why it matters

Значения, константы и числа

Значения, константы и числа

Карта темы

Частые ошибки и ловушки

Значение для собеседований

Values, Constants & Numbers

Values, Constants & Numbers

Topic map

Common Mistakes and Traps

Interview Relevance

Значения, константы и числа

Значения, константы и числа

Карта темы

Частые ошибки и ловушки

Значение для собеседований

Values, Constants & Numbers

Values, Constants & Numbers

Topic map

Common Mistakes and Traps

Interview Relevance