Golang int zu string, string zu int und Typkonvertierung

Go konvertiert Typen nie implizit. Zwischen kompatiblen Typen konvertierst du mit T(v), zwischen Zahlen und Text mit dem Paket strconv. Die beiden meistgesuchten Konvertierungen:

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“) formatiert ein int als Dezimaltext. strconv.Atoi („ASCII to integer“) parst Text in ein int und gibt einen Fehler zurück, wenn der Text keine gültige Zahl ist. Prüf diesen Fehler immer.

Die Konvertierung T(v)

Die Syntax für Konvertierungen in Go sieht aus wie ein Funktionsaufruf, benannt nach dem Zieltyp. Sie funktioniert in drei Situationen:

1. zwischen numerischen Typen (int, int64, float64, uint8, ...),
2. zwischen string und []byte oder []rune,
3. zwischen Typen, die sich einen zugrunde liegenden Typ teilen (Celsius und 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)
}

Sieh dir die Ergebnisse genau an:

• int(3.9) ist 3 und int(-3.9) ist -3. Die Konvertierung schneidet in Richtung null ab; sie rundet nicht. Nimm vorher math.Round, math.Floor oder math.Ceil, um das Verhalten zu wählen. math.Round rundet bei ,5 von null weg, also wird -3.5 zu -4.
• uint8(300) ist 44, weil nur die unteren 8 Bit übrig bleiben (300 minus 256), und int8(200) ist aus demselben Grund -56. Kein Fehler, keine Panic.
• Celsius und float64 teilen sich einen zugrunde liegenden Typ, also lassen sie sich frei konvertieren, aber nur explizit.

Die Werte stehen absichtlich in Variablen. Mit Konstanten kompilieren dieselben Konvertierungen nicht.

Konstanten werden geprüft, Variablen nicht

Eine Konstante zu konvertieren, die nicht passt, ist ein Compilerfehler. Eine Variable mit demselben Wert zu konvertieren läuft still über:

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

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

Auch eine nicht ganzzahlige Konstante in einen Ganzzahltyp zu konvertieren wird abgelehnt, während derselbe Wert in einer Variablen abgeschnitten wird:

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

Liegt der Float-Wert außerhalb des Bereichs des Ganzzahl-Zieltyps (etwa int64(1e20)), ist das Ergebnis implementierungsabhängig: amd64 und arm64 liefern zum Beispiel verschiedene Antworten. Prüf den Bereich, bevor du nicht vertrauenswürdige Werte konvertierst.

Zahlen in Strings konvertieren

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 nimmt ein Format-Byte ('f' für Festkomma, 'e' für Exponent, 'g' für die kürzere Variante), eine Genauigkeit (-1 bedeutet „die wenigsten Ziffern, die sich exakt zurückverwandeln lassen“) und die Bitgröße des ursprünglichen Floats (64 oder 32).

strconv ist schneller als fmt.Sprint, das den Wert in ein Interface packt und den allgemeinen Formatierungspfad von fmt durchläuft. In einer heißen Schleife macht sich das bemerkbar; bei gelegentlichen Konvertierungen nimm, was sich besser liest.

Strings in Zahlen konvertieren

ParseInt gibt immer ein int64 zurück. Das Argument bitSize (0, 8, 16, 32, 64) legt den akzeptierten Bereich fest, also passt das Ergebnis garantiert, wenn du es herunterkonvertierst. base 0 bedeutet „aus dem Präfix ableiten“, also werden 0x1f, 0o17, 0b101 und 1_000 alle geparst.

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

Was die Ausgabe zeigt:

• " 42" scheitert. Atoi akzeptiert ein optionales Vorzeichen und Ziffern, sonst nichts. Eingaben aus bufio enden meist mit \n, also kürze sie vorher.
• "4.2" ist für Atoi ungültig. Für Dezimalzahlen nimm ParseFloat.
• Bei einem Bereichsfehler gibt ParseInt den größten passenden Wert (127 für int8) zusammen mit dem Fehler zurück. Verwende den Wert nicht, wenn der Fehler nicht nil ist.
• Die Fehler sind *strconv.NumError-Werte, die strconv.ErrSyntax oder strconv.ErrRange wrappen, also kann errors.Is sie unterscheiden.

ParseBool akzeptiert 1, t, T, TRUE, true, True und die entsprechenden Formen für false. "yes" und "on" sind Fehler.

Die Falle string(65)

Eine Ganzzahl in string zu konvertieren erzeugt keine Ziffern. Es erzeugt das Zeichen mit diesem Unicode-Codepoint:

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

Der Compiler akzeptiert das, aber go vet meldet es:

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

Willst du wirklich das Zeichen, sag es mit einer Rune: string(rune(n)). Willst du die Zahl als Text, nimm strconv.Itoa(n). Eine rune oder ein byte in string zu konvertieren ist in Ordnung und verbreitet:

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
}

Strings, Bytes und Runes

string, []byte und []rune lassen sich mit T(v) ineinander konvertieren. Jede Konvertierung kopiert die Daten, weil Strings unveränderlich sind und Slices nicht:

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
}

Konvertiere in []rune, wenn du zeichenweise indizieren oder ändern musst; konvertiere in []byte für I/O, Hashing und Änderungen auf Byte-Ebene. Die Seite zu Runes und Bytes erklärt UTF-8 im Detail.

Konvertierung vs Type Assertion

Eine Konvertierung macht aus einem Wert eines konkreten Typs einen anderen. Den konkreten Wert aus einem Interface (any, error, io.Reader) zu holen ist eine andere Operation, die 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

Erst die Assertion, dann die Konvertierung. Die Comma-ok-Form n, ok := v.(int) vermeidet eine Panic, wenn der Typ falsch ist.

Kurzreferenz

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