Преобразование типов и strconv
Go не делает неявных преобразований. Если нужно из string получить int - нужно сказать это явно. Это защищает от багов, но нужно знать как. Основы про типы - в уроке Переменные и типы: var, := и нулевые значения. Тот же синтаксис T(v) работает и для собственных типов: Celsius(36.6), UserID(42) - зачем их вообще объявлять, разобрано в уроке про определяемые типы.
Преобразование между числовыми типами
var x int = 42
var y float64 = float64(x) // int → float64
var z int32 = int32(x) // int → int32
// Потеря данных при сужении типа!
var big int64 = 1_000_000
var small int8 = int8(big) // overflow: 64 (остался только младший байт 0x40)
// Без явного T(v) - ошибка компиляции:
// var f float64 = 3.14; var n int = f // cannot use f (float64) as int
// var s string = string(3.14) // float нельзя превратить в string через string(...)
⚠️ Потеря данных
При преобразовании большого типа в маленький (int64 → int8) Go не предупреждает! Данные молча обрезаются. Проверяй границы сам.
Строка ↔ Число: пакет strconv
Это главный пакет для преобразования строк в числа и обратно.
Строка → Число
import "strconv"
// Строка → int
num, err := strconv.Atoi("42")
if err != nil {
fmt.Println("Ошибка:", err)
}
fmt.Println(num) // 42
// Строка → int64 (с указанием основания и разрядности)
num64, err := strconv.ParseInt("FF", 16, 64)
fmt.Println(num64) // 255
// Строка → float64
price, err := strconv.ParseFloat("99.99", 64)
fmt.Println(price) // 99.99
// Строка → bool
flag, err := strconv.ParseBool("true")
fmt.Println(flag) // true
Число → Строка
// int → строка
s := strconv.Itoa(42)
fmt.Println(s) // "42"
// float → строка
s2 := strconv.FormatFloat(3.14159, 'f', 2, 64)
fmt.Println(s2) // "3.14"
// Через fmt.Sprintf (универсальный способ, но медленнее strconv:
// ему каждый раз нужно разобрать строку формата)
s3 := fmt.Sprintf("%d", 42)
s4 := fmt.Sprintf("%.2f", 3.14)
s5 := fmt.Sprintf("%t", true)
| Задача | Функция | Пример |
|---|---|---|
| string → int | strconv.Atoi | Atoi("42") → 42 |
| int → string | strconv.Itoa | Itoa(42) → "42" |
| string → float64 | strconv.ParseFloat | ParseFloat("3.14", 64) → 3.14 |
| string → int64 | strconv.ParseInt | ParseInt("FF", 16, 64) → 255 |
| string → bool | strconv.ParseBool | ParseBool("true") → true |
| любой → string | fmt.Sprintf | Sprintf("%d", 42) → "42" |
Обработка ошибок преобразования
Преобразование может не удаться - всегда проверяй error (подробнее - в уроке Обработка ошибок):
inputs := []string{"42", "hello", "3.14", "", "-7"}
for _, s := range inputs {
num, err := strconv.Atoi(s)
if err != nil {
fmt.Printf(" %q - ошибка: %v\n", s, err) // при ошибке num == 0
} else {
fmt.Printf(" %q → %d\n", s, num)
}
}
// "42" → 42
// "hello" - ошибка: strconv.Atoi: parsing "hello": invalid syntax
// "3.14" - ошибка: strconv.Atoi: parsing "3.14": invalid syntax
// "" - ошибка: strconv.Atoi: parsing "": invalid syntax
// "-7" → -7
Строка ↔ Байты
// string → []byte
s := "Привет"
b := []byte(s)
fmt.Println(b) // [208 159 209 ...]
// []byte → string
s2 := string(b)
fmt.Println(s2) // Привет
// int → rune → string
r := rune(65)
fmt.Println(string(r)) // A
ℹ️ string vs []byte
В Go строка - это неизменяемая последовательность байтов.
[]byte- изменяемая копия. Конвертация создаёт копию данных.
Практический пример: парсинг конфига
func parseConfig(lines []string) map[string]interface{} {
config := make(map[string]interface{})
for _, line := range lines {
parts := strings.SplitN(line, "=", 2)
if len(parts) != 2 {
continue
}
key := strings.TrimSpace(parts[0])
val := strings.TrimSpace(parts[1])
// Пробуем разные типы
if i, err := strconv.Atoi(val); err == nil {
config[key] = i
} else if f, err := strconv.ParseFloat(val, 64); err == nil {
config[key] = f
} else if b, err := strconv.ParseBool(val); err == nil {
config[key] = b
} else {
config[key] = val // оставляем как строку
}
}
return config
}
// port=8080 → int 8080
// rate=0.5 → float64 0.5
// debug=true → bool true
// host=localhost → string "localhost"
Обратно из interface{}: type assertion
parseConfig сложил в map значения разных типов. Достать число назад через int(config["port"]) нельзя: это не преобразование, а проверка, что внутри interface{} лежит именно int. Для этого есть type assertion с , ok и type switch:
port, ok := config["port"].(int) // ok == false, если там не int: паники нет
if !ok {
port = 8080
}
switch v := config["rate"].(type) {
case int:
fmt.Println("целое:", v)
case float64:
fmt.Println("дробное:", v)
default:
fmt.Println("что-то другое")
}
Форма без , ok (config["port"].(int)) паникует на чужом типе. Подробно про пустой интерфейс, assertion и type switch - в уроке Интерфейсы.
Типичные ошибки
// ОШИБКА: string(число) - это не то, что ты думаешь!
fmt.Println(string(65)) // "A" (Unicode символ), НЕ "65"!
fmt.Println(strconv.Itoa(65)) // "65" - правильно
// ОШИБКА: забыть проверить err
num, _ := strconv.Atoi(userInput) // если "abc" → num будет 0 без ошибки!
Мини-задание
- Передай в
strconv.Atoiмусор и напечатай саму ошибку целиком. Она содержит и функцию, и входные данные - Преобразуй
int64со значением большеmath.MaxInt32вint32и посмотри результат. Компилятор промолчит, число испортится - Сравни
string(65)иstrconv.Itoa(65). Первое даст букву: запустиgo vetи прочитай предупреждение - Разбери число с плавающей точкой через
strconv.ParseFloatс разной разрядностью (32 и 64) и сравни - Сделай
b := []byte(s), измениb[0]и убедись, чтоsне изменилась: копирование реальное