Int na string, string na int i konwersja typów w Golang

Go nigdy nie konwertuje typów niejawnie. Między zgodnymi typami konwertujesz przez T(v), a między liczbami i tekstem przez pakiet strconv. Dwie najczęściej wyszukiwane konwersje:

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”) formatuje int jako tekst dziesiętny. strconv.Atoi („ASCII to integer”) parsuje tekst na int i zwraca błąd, gdy tekst nie jest poprawną liczbą. Zawsze sprawdzaj ten błąd.

Konwersja T(v)

Składnia konwersji w Go wygląda jak wywołanie funkcji nazwanej tak jak typ docelowy. Działa w trzech sytuacjach:

1. między typami liczbowymi (int, int64, float64, uint8, ...),
2. między string a []byte lub []rune,
3. między typami, które mają wspólny typ bazowy (Celsius i 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)
}

Przyjrzyj się wynikom:

• int(3.9) to 3, a int(-3.9) to -3. Konwersja obcina w stronę zera; nie zaokrągla. Aby wybrać zachowanie, najpierw użyj math.Round, math.Floor lub math.Ceil. math.Round zaokrągla połówki od zera, więc -3.5 staje się -4.
• uint8(300) to 44, bo zostaje tylko 8 najmłodszych bitów (300 minus 256), a int8(200) to -56 z tego samego powodu. Bez błędu i bez panic.
• Celsius i float64 mają wspólny typ bazowy, więc konwertują się swobodnie, ale tylko jawnie.

Wartości są celowo w zmiennych. Ze stałymi te same konwersje się nie kompilują.

Stałe są sprawdzane, zmienne nie

Konwersja stałej, która się nie mieści, to błąd kompilacji. Konwersja zmiennej o tej samej wartości po cichu zawija wartość:

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

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

Konwersja stałej niecałkowitej na typ całkowity też jest odrzucana, a ta sama wartość w zmiennej jest obcinana:

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

Jeśli liczba zmiennoprzecinkowa jest poza zakresem docelowego typu całkowitego (na przykład int64(1e20)), wynik zależy od implementacji: na przykład amd64 i arm64 dają różne odpowiedzi. Sprawdzaj zakres przed konwersją niezaufanych wartości.

Konwersja liczb na stringi

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 przyjmuje bajt formatu ('f' dla stałego przecinka, 'e' dla wykładnika, 'g' dla krótszej z tych form), precyzję (-1 oznacza „najmniej cyfr, które pozwalają dokładnie odtworzyć wartość”) i rozmiar w bitach oryginalnej liczby (64 lub 32).

strconv jest szybszy niż fmt.Sprint, który opakowuje wartość w interfejs i przechodzi przez ogólną ścieżkę formatowania fmt. W gorącej pętli ta różnica jest widoczna; przy sporadycznych konwersjach wybierz to, co czyta się lepiej.

Konwersja stringów na liczby

ParseInt zawsze zwraca int64. Argument bitSize (0, 8, 16, 32, 64) ustala akceptowany zakres, więc wynik na pewno się zmieści, gdy przekonwertujesz go na mniejszy typ. base 0 oznacza „wywnioskuj z prefiksu”, więc 0x1f, 0o17, 0b101 i 1_000 są parsowane.

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)
}

Co pokazuje wynik:

• " 42" się nie parsuje. Atoi akceptuje opcjonalny znak i cyfry, nic więcej. Dane z bufio zwykle kończą się na \n, więc je przytnij.
• "4.2" jest niepoprawne dla Atoi. Do liczb dziesiętnych użyj ParseFloat.
• Przy błędzie przekroczenia zakresu ParseInt zwraca największą wartość, która się mieści (127 dla int8), razem z błędem. Nie używaj tej wartości, gdy błąd nie jest nil.
• Błędy to wartości *strconv.NumError opakowujące strconv.ErrSyntax lub strconv.ErrRange, więc errors.Is potrafi je odróżnić.

ParseBool akceptuje 1, t, T, TRUE, true, True i odpowiadające im formy dla fałszu. "yes" i "on" to błędy.

Pułapka string(65)

Konwersja liczby całkowitej na string nie daje cyfr. Daje znak o tym punkcie kodowym Unicode:

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

Kompilator to akceptuje, ale go vet to zgłasza:

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

Jeśli naprawdę chcesz znak, powiedz to wprost przez runę: string(rune(n)). Jeśli chcesz liczbę jako tekst, użyj strconv.Itoa(n). Konwersja rune lub byte na string jest poprawna i częsta:

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
}

Stringi, bajty i rune

string, []byte i []rune konwertują się między sobą przez T(v). Każda konwersja kopiuje dane, bo stringi są niezmienne, a slice'y nie:

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
}

Konwertuj na []rune, gdy musisz indeksować lub modyfikować po znakach; konwertuj na []byte do wejścia i wyjścia, hashowania i edycji na poziomie bajtów. Strona o runach i bajtach szczegółowo omawia UTF-8.

Konwersja a asercja typu

Konwersja zmienia wartość z jednego typu konkretnego na inny. Wydobycie konkretnej wartości z interfejsu (any, error, io.Reader) to inna operacja, asercja typu:

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

Najpierw asercja, potem konwersja. Forma comma-ok n, ok := v.(int) pozwala uniknąć panic, gdy typ jest zły.

Ściągawka

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