Golang: int в string, string в int и преобразование типов

Go никогда не преобразует типы неявно. Между совместимыми типами вы преобразуете через T(v), а между числами и текстом через пакет strconv. Два самых популярных в поиске преобразования:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa («integer to ASCII») форматирует int как десятичный текст. strconv.Atoi («ASCII to integer») разбирает текст в int и возвращает ошибку, если текст не является корректным числом. Всегда проверяйте эту ошибку.

Преобразование T(v)

Синтаксис преобразования в Go похож на вызов функции с именем целевого типа. Он работает в трёх случаях:

1. между числовыми типами (int, int64, float64, uint8, ...),
2. между string и []byte или []rune,
3. между типами с общим базовым типом (Celsius и float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

Посмотрите на результаты внимательно:

• int(3.9) равно 3, а int(-3.9) равно -3. Преобразование отбрасывает дробную часть в сторону нуля, а не округляет. Чтобы выбрать поведение, сначала примените math.Round, math.Floor или math.Ceil. math.Round округляет половину от нуля, поэтому -3.5 становится -4.
• uint8(300) равно 44, потому что остаются только младшие 8 бит (300 минус 256), а int8(200) по той же причине равно -56. Ни ошибки, ни паники.
• У Celsius и float64 общий базовый тип, поэтому они свободно преобразуются друг в друга, но только явно.

Значения намеренно лежат в переменных. С константами те же преобразования не скомпилируются.

Константы проверяются, переменные нет

Преобразование константы, которая не помещается в тип, это ошибка компиляции. Преобразование переменной с тем же значением молча заворачивается:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

Преобразование нецелой константы в целочисленный тип тоже отвергается, а то же значение в переменной просто усекается:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

Если значение float выходит за диапазон целевого целочисленного типа (скажем, int64(1e20)), результат зависит от реализации: например, amd64 и arm64 дают разные ответы. Проверяйте диапазон, прежде чем преобразовывать непроверенные значения.

Преобразование чисел в строки

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat принимает байт формата ('f' для фиксированной записи, 'e' для экспоненциальной, 'g' для той, что короче), точность (-1 означает «наименьшее число цифр, которое точно восстанавливает значение») и разрядность исходного float (64 или 32).

strconv быстрее, чем fmt.Sprint, который упаковывает значение в интерфейс и проходит через общий путь форматирования fmt. В горячем цикле разница заметна; для редких преобразований выбирайте то, что лучше читается.

Преобразование строк в числа

ParseInt всегда возвращает int64. Аргумент bitSize (0, 8, 16, 32, 64) задаёт допустимый диапазон, так что результат гарантированно поместится, когда вы преобразуете его в меньший тип. base 0 означает «определить по префиксу», поэтому разбираются 0x1f, 0o17, 0b101 и 1_000.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

Что показывает вывод:

• " 42" не разбирается. Atoi принимает необязательный знак и цифры, больше ничего. Ввод из bufio обычно заканчивается на \n, поэтому обрезайте его.
• "4.2" для Atoi некорректно. Для дробных чисел используйте ParseFloat.
• При ошибке выхода за диапазон ParseInt возвращает наибольшее значение, которое помещается (127 для int8), вместе с ошибкой. Не используйте значение, если ошибка не nil.
• Ошибки имеют тип *strconv.NumError и оборачивают strconv.ErrSyntax или strconv.ErrRange, поэтому errors.Is может их различить.

ParseBool принимает 1, t, T, TRUE, true, True и соответствующие формы false. "yes" и "on" дают ошибку.

Ловушка string(65)

Преобразование целого числа в string не даёт цифры. Оно даёт символ с этой кодовой точкой Unicode:

n := 65
s := string(n) // "A", not "65"

Компилятор это пропускает, но go vet сообщает:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

Если вам действительно нужен символ, скажите это явно через руну: string(rune(n)). Если нужно число в виде текста, используйте strconv.Itoa(n). Преобразовать rune или byte в string можно, и это обычное дело:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

Строки, байты и руны

string, []byte и []rune преобразуются друг в друга через T(v). Каждое преобразование копирует данные, потому что строки неизменяемы, а слайсы нет:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

Преобразуйте в []rune, когда нужно индексировать или изменять по символам; в []byte для ввода-вывода, хеширования и правок на уровне байтов. UTF-8 подробно разобран на странице о рунах и байтах.

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

Преобразование меняет значение одного конкретного типа на другой. Достать конкретное значение из интерфейса (any, error, io.Reader) это другая операция, утверждение типа (type assertion):

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

Сначала утверждение, затем преобразование. Форма comma-ok n, ok := v.(int) позволяет избежать паники, если тип не тот.

Шпаргалка

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}