Часть 2. Основы языкаУрок 04# go# основы# типы

Типы данных и преобразования

числа, строки, rune, bool, таблица zero values, явные преобразования

Цели главы

  • Знать базовые типы и когда какой выбирать.
  • Понимать, почему float не годится для денег.
  • Отличать string от rune и байты от символов.
  • Помнить нулевые значения всех типов.
  • Делать явные преобразования и понимать, что при этом теряется.

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

Каждая переменная в Go привязана к конкретному типу, и Go не смешивает типы молча: сложить строку и число или int с float64 не получится — код просто не скомпилируется. Это плюс: строгая типизация ловит ошибки на этапе компиляции, а не в продакшене.

Целые числа

int — основной тип для целых. На 64-битных системах он 64-битный, этого хватает для любых повседневных задач. Подчёркивания в числовых литералах игнорируются — они только для читаемости: 1_500_000.

Тип Диапазон
int8 от −128 до 127
int16 от −32 768 до 32 767
int32 примерно ±2,1 миллиарда
int64 примерно ±9,2 квинтиллиона (9·10¹⁸)
uint8 (он же byte) от 0 до 255

В 99% случаев хватает обычного int; типы с фиксированным размером нужны для протоколов, файлов и экономии памяти.

go
package main

import (
    "fmt"
    "math"
)

func main() {
    var zeroInt int
    views := 1_500_000
    fmt.Println(zeroInt, views)

    fmt.Println(math.MinInt8, math.MaxInt8)
    fmt.Println(math.MinInt16, math.MaxInt16)
    fmt.Println(math.MaxInt32, math.MaxInt64)

    var level int8 = 127
    level++ // переполнение в рантайме молча «заворачивается»
    fmt.Println(level)
}
stdout // вывод программы
0 1500000
-128 127
-32768 32767
2147483647 9223372036854775807
-128

Дробные числа

Для дробей есть float32 и float64. float64 точнее — около 15–17 значащих цифр — и используется по умолчанию; float32 хранит около 7 значащих цифр и нужен редко, ради экономии памяти. Короче: всегда бери float64.

go
package main

import "fmt"

func main() {
    var zeroFloat float64
    avg := 85.5
    fmt.Println(zeroFloat, avg)

    a, b := 0.1, 0.2
    fmt.Println(a + b)     // ошибка двоичного представления
    fmt.Println(0.1 + 0.2) // константы складываются точно ещё при компиляции

    priceKopecks := 99_900 // 999 рублей 00 копеек
    fmt.Printf("%d.%02d руб.\n", priceKopecks/100, priceKopecks%100)
}
stdout // вывод программы
0 85.5
0.30000000000000004
0.3
999.00 руб.

Строки

string — последовательность символов в двойных кавычках; нулевое значение — пустая строка. Строка в обратных кавычках (raw string) переносится как есть, со всеми переводами строк, а escape-последовательности вроде \n в ней не работают. Это удобно для многострочного текста, путей, JSON и SQL.

go
package main

import "fmt"

func main() {
    var zeroString string
    title := "Интерстеллар"
    fmt.Printf("[%s] [%s]\n", zeroString, title)

    synopsis := `Строка в обратных кавычках
переносится как есть,
а \n здесь — просто два символа`
    fmt.Println(synopsis)
}
stdout // вывод программы
[] [Интерстеллар]
Строка в обратных кавычках
переносится как есть,
а \n здесь — просто два символа

rune — один символ

rune — один символ в одинарных кавычках. На самом деле это число: код символа в Unicode (тип rune — псевдоним int32). Поэтому Println печатает число, а чтобы увидеть сам символ, нужен плейсхолдер %c.

go
package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    var letter rune = 'A'
    fmt.Println(letter)        // rune хранит код символа
    fmt.Printf("%c\n", letter) // %c печатает сам символ
    fmt.Println('Я', '⭐')

    word := "Фильм"
    fmt.Println(len(word), utf8.RuneCountInString(word))
}
stdout // вывод программы
65
A
1071 11088
10 5

bool

bool принимает только true или false; нулевое значение — false. Используется в условиях, фильтрах и флагах: isPremium, hasSubtitles.

Нулевые значения

Go гарантирует: объявленная без значения переменная содержит не мусор, а предсказуемое нулевое значение (zero value).

Тип Нулевое значение
int, int8…int64, uint, byte, rune, float32, float64 0
string "" — пустая строка
bool false
указатель *T, слайс []T, мапа map[K]V, канал chan T, функция, интерфейс nil
структура каждое поле — нулевое значение своего типа
массив [N]T каждый элемент — нулевое значение T
go
package main

import "fmt"

func main() {
    var (
        i  int
        f  float64
        s  string
        b  bool
        p  *int
        sl []int
        m  map[string]int
    )
    fmt.Printf("%v %v %q %v %v %v %v\n", i, f, s, b, p, sl, m)
    fmt.Println(p == nil, sl == nil, m == nil)
}
stdout // вывод программы
0 0 "" false <nil> [] map[]
true true true

Преобразование типов

Go не конвертирует типы автоматически: int и float64 нельзя перемножить напрямую.

go
episodes := 8
avgLength := 52.5
total := episodes * avgLength // invalid operation: episodes * avgLength (mismatched types int and float64)

Преобразование всегда явное и пишется как вызов: Тип(значение).

go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    episodes := 8
    avgLength := 52.5

    total := float64(episodes) * avgLength // 8.0 * 52.5
    rough := episodes * int(avgLength)     // int(52.5) = 52 — дробная часть отброшена
    fmt.Println(total, rough)

    year := 2014
    fmt.Println(strconv.Itoa(year) + " год") // число → строка
    fmt.Println(string(rune(65)))            // из кода символа получаем символ

    n, err := strconv.Atoi("169") // строка → число, может вернуть ошибку
    fmt.Println(n+1, err)
}
stdout // вывод программы
420 416
2014 год
A
170 <nil>
  • Приводить «вверх» безопасно: float64(episodes) не теряет данных — получаем 420 минут.
  • Приводить «вниз» опасно: int(52.5) отбрасывает дробную часть, и вместо 420 выходит 416.
  • string(число) даёт не цифры, а символ с таким кодом. Число в строку переводят через strconv.Itoa или fmt.Sprint.

Практика

Домашнее задание: конвертеры для GoFlix

  1. Длительность фильма дана в секундах, например 8520. Переведи её в формат «X ч Y мин Z с» через деление / и остаток % и выведи через Printf.
  2. Размер файла фильма дан в байтах, например 4 831 838 208. Переведи в гигабайты через float64 и выведи с двумя знаками после точки.
решениеЭталонное решение
go
package main

import "fmt"

func main() {
    duration := 8520 // секунды
    hours := duration / 3600
    minutes := duration % 3600 / 60
    seconds := duration % 60
    fmt.Printf("Длительность: %d ч %d мин %d с\n", hours, minutes, seconds)

    size := 4_831_838_208 // байты
    gib := float64(size) / (1024 * 1024 * 1024)
    gb := float64(size) / 1e9
    fmt.Printf("Размер: %.2f ГиБ (%.2f ГБ)\n", gib, gb)
}
stdout // вывод программы
Длительность: 2 ч 22 мин 0 с
Размер: 4.50 ГиБ (4.83 ГБ)

Тренировка: предскажи вывод

go
package main

import "fmt"

func main() {
    fmt.Println(7/2, 7.0/2, 7%3, -7%3)
    f := 3.99
    fmt.Println(int(f))
}
самопроверкаОтвет
text
3 3.5 1 -1
3

Деление целых отбрасывает дробную часть; 7.0/2 — дробная константа, поэтому 3.5; знак остатка совпадает со знаком делимого. int(f) отбрасывает дробь без округления. А вот int(3.99) с константой не скомпилируется: cannot convert 3.99 (untyped float constant) to type int.

Проверь себя

вопросЧто значит «строгая типизация» и чем она полезна?

Каждая переменная привязана к типу, и типы не смешиваются без явного преобразования. Ошибки ловятся при компиляции, а не в продакшене.

вопросПочему деньги не хранят во float64 и как хранить правильно?

Дробные числа хранятся в двоичном виде с погрешностью: 0.1 + 0.2 даёт 0.30000000000000004. Деньги хранят в копейках или центах целым числом (int64).

вопросЧто такое rune и что напечатает fmt.Println('A')?

rune — код символа Unicode, псевдоним int32. Println('A') напечатает 65; символ печатают через %c.

вопросПочему len("Фильм") возвращает 10?

len считает байты, а строка хранится в UTF-8, где кириллическая буква занимает 2 байта. Символы считает utf8.RuneCountInString.

самопроверкаПеречисли нулевые значения для int, string, bool, слайса и мапы.

0, "", false, nil, nil.

вопросКак перевести int в строку и почему не через string(n)?

strconv.Itoa(n) или fmt.Sprint(n). string(n) вернёт символ с кодом n, а не цифры.


Ключевые выводы

  • 🧱 Go строго типизирован: типы не смешиваются, ошибки ловит компилятор.
  • 🔢 int — для целых, float64 — для дробей; деньги храни целыми копейками.
  • 🔤 string — байты в UTF-8, rune — код одного символа; len считает байты.
  • 0️⃣ У каждого типа есть нулевое значение: 0, "", false, nil.
  • 🔄 Преобразование только явное: float64(n), int(f); числа в строки — через strconv.
// связанные темы и шпаргалки