Da int a stringa e da stringa a int in Golang: conversione di tipo

Go non converte mai i tipi in modo implicito. Converti tra tipi compatibili con T(v), e tra numeri e testo con il pacchetto strconv. Le due conversioni più cercate:

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") formatta un int come testo decimale. strconv.Atoi ("ASCII to integer") interpreta un testo come int e restituisce un errore quando il testo non è un numero valido. Controlla sempre quell'errore.

La conversione T(v)

La sintassi di conversione di Go sembra una chiamata di funzione con il nome del tipo di destinazione. Funziona in tre situazioni:

1. tra tipi numerici (int, int64, float64, uint8, ...),
2. tra string e []byte o []rune,
3. tra tipi che condividono lo stesso tipo sottostante (Celsius e 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)
}

Guarda bene i risultati:

• int(3.9) è 3 e int(-3.9) è -3. La conversione tronca verso lo zero; non arrotonda. Usa prima math.Round, math.Floor o math.Ceil per scegliere il comportamento. math.Round arrotonda le metà allontanandosi dallo zero, quindi -3.5 diventa -4.
• uint8(300) è 44, perché sopravvivono solo gli 8 bit bassi (300 meno 256), e int8(200) è -56 per lo stesso motivo. Nessun errore, nessun panic.
• Celsius e float64 condividono il tipo sottostante, quindi si convertono liberamente, ma solo in modo esplicito.

I valori stanno in variabili di proposito. Con le costanti, le stesse conversioni non compilano.

Le costanti vengono controllate, le variabili no

Convertire una costante che non ci sta è un errore di compilazione. Convertire una variabile con lo stesso valore fa un wrap-around silenzioso:

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

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

Anche convertire una costante non intera in un tipo intero viene rifiutato, mentre lo stesso valore in una variabile viene troncato:

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

Se il valore float è fuori dall'intervallo del tipo intero di destinazione (per esempio int64(1e20)), il risultato dipende dall'implementazione: amd64 e arm64, per esempio, danno risposte diverse. Controlla l'intervallo prima di convertire valori non affidabili.

Convertire numeri in stringhe

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 accetta un byte di formato ('f' per la notazione fissa, 'e' per quella esponenziale, 'g' per la più breve delle due), una precisione (-1 significa "il minor numero di cifre che permette di tornare esattamente al valore") e la dimensione in bit del float originale (64 o 32).

strconv è più veloce di fmt.Sprint, che racchiude il valore in un'interfaccia e passa per il percorso di formattazione generico di fmt. In un ciclo critico la differenza si nota; per conversioni occasionali, scegli quella che si legge meglio.

Convertire stringhe in numeri

ParseInt restituisce sempre un int64. L'argomento bitSize (0, 8, 16, 32, 64) stabilisce l'intervallo accettato, quindi il risultato è garantito entrare nel tipo più piccolo quando lo converti. base 0 significa "deduci dal prefisso", quindi 0x1f, 0o17, 0b101 e 1_000 vengono tutti interpretati.

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

Cosa mostra l'output:

• " 42" fallisce. Atoi accetta un segno facoltativo e delle cifre, nient'altro. L'input letto con bufio di solito termina con \n, quindi rimuovilo.
• "4.2" non è valido per Atoi. Usa ParseFloat per i decimali.
• In caso di errore di intervallo, ParseInt restituisce il valore più grande che ci sta (127 per int8) insieme all'errore. Non usare il valore quando l'errore non è nil.
• Gli errori sono valori *strconv.NumError che incapsulano strconv.ErrSyntax o strconv.ErrRange, quindi errors.Is può distinguerli.

ParseBool accetta 1, t, T, TRUE, true, True e le forme corrispondenti per false. "yes" e "on" sono errori.

La trappola di string(65)

Convertire un intero in string non produce cifre. Produce il carattere con quel code point Unicode:

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

Il compilatore lo accetta, ma go vet lo segnala:

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

Se vuoi davvero il carattere, dillo con una rune: string(rune(n)). Se vuoi il numero come testo, usa strconv.Itoa(n). Convertire una rune o un byte in string va bene ed è comune:

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
}

Stringhe, byte e rune

string, []byte e []rune si convertono l'uno nell'altro con T(v). Ogni conversione copia i dati, perché le stringhe sono immutabili e gli slice no:

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
}

Converti in []rune quando devi indicizzare o modificare per carattere; converti in []byte per I/O, hashing e modifiche a livello di byte. La pagina su rune e byte tratta UTF-8 in dettaglio.

Conversione e type assertion

Una conversione trasforma un valore da un tipo concreto a un altro. Estrarre il valore concreto da un'interfaccia (any, error, io.Reader) è un'operazione diversa, la 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

Prima asserisci, poi converti. La forma comma-ok n, ok := v.(int) evita un panic quando il tipo è sbagliato.

Riferimento rapido

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