Tipi di dati in Golang: int, float64, string, bool, byte, rune

I tipi base di Go sono numeri, booleani e stringhe. Ogni variabile ha esattamente un tipo, fissato in fase di compilazione, e Go non converte mai i tipi al posto tuo. %T stampa il tipo di qualsiasi valore:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

Nota che 'G' viene stampato come 71 con tipo int32: un carattere tra apici singoli è una rune, cioè un numero (il code point Unicode). rune è un alias di int32 (lo stesso tipo con un secondo nome), quindi %T riporta int32. Allo stesso modo byte riporta uint8.

Interi

Usa int come scelta predefinita. len() restituisce int, gli indici degli slice sono int e i contatori dei cicli sono int. Su ogni piattaforma a 64 bit int è a 64 bit. Ricorri ai tipi con dimensione quando la dimensione fa parte di un contratto: int32 in un formato di file binario, uint8 per i byte grezzi, int64 per un timestamp Unix in nanosecondi.

Evita i tipi senza segno per quantità che "non possono essere negative", come i conteggi. Sottrarre oltre lo zero fa ricominciare da un numero enorme invece di produrre un valore negativo che potresti intercettare.

Limiti e overflow

Il package math ha una costante per ogni limite. Durante l'esecuzione, un'operazione aritmetica intera che va in overflow ricomincia silenziosamente dall'altro estremo:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

Nessun panic, nessun errore: 127 + 1 diventa -128. Solo le espressioni costanti vengono controllate in fase di compilazione (var b int8 = 128 non compila). Se nei tuoi dati è possibile un overflow, controlla prima dell'operazione oppure usa math/big.

Letterali interi

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Numeri in virgola mobile

Un letterale con punto decimale o esponente (2.5, 1e6) è float64 per impostazione predefinita, e il package math riceve e restituisce float64. Usalo, a meno che non conti la memoria in un array grande.

I float sono binari, quindi la maggior parte delle frazioni decimali sono approssimazioni:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

Ne seguono due regole. Non confrontare mai i float con == dopo dei calcoli. E non memorizzare mai denaro in un float: usa un numero intero di centesimi o una libreria decimale.

Dividere un float per zero dà +Inf, -Inf o NaN invece di provocare un panic. Dividere un intero per zero provoca un panic durante l'esecuzione (runtime error: integer divide by zero), e un divisore zero costante è un errore di compilazione.

Booleani

bool contiene true o false, e il suo valore zero è false. Go non tratta numeri, stringhe vuote o nil come booleani. if count {} è un errore di compilazione; scrivi if count > 0 {}. Gli operatori sono &&, || e !, e && e || sono valutati in cortocircuito.

Stringhe

Una string è una sequenza immutabile di byte, di solito testo UTF-8. len(s) conta i byte, non i caratteri:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é occupa due byte in UTF-8, quindi len riporta 6 per cinque caratteri. Le stringhe tra virgolette doppie elaborano le sequenze di escape come \n; le stringhe grezze tra backtick no, e possono occupare più righe. La pagina sulle stringhe tratta il package strings, e quella su rune e byte approfondisce UTF-8.

byte e rune

Sono alias, non tipi nuovi: un byte e un uint8 sono intercambiabili senza conversione. I nomi dicono cosa significa il numero.

Numeri complessi

Go ha tipi complessi integrati, complex64 e complex128, con real, imag e il package math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Servono a pochi programmi, ma l'elaborazione dei segnali e un po' di codice numerico li usano.

Tipi composti e di riferimento

I tipi base si combinano in tipi composti. Ognuno ha la sua pagina:

any è un alias di interface{} (da Go 1.18) e può contenere un valore di qualsiasi tipo.

Tipi con nome

Puoi definire un nuovo tipo a partire da uno esistente. Ha la stessa rappresentazione ma è un tipo distinto, e può avere dei metodi:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

Questa rigidità è proprio lo scopo: un UserID non può essere passato per sbaglio dove è atteso un OrderID. Converti esplicitamente quando è ciò che intendi: float64(t). Consulta la conversione di tipo per le regole e le funzioni di strconv per passare tra numeri e stringhe.

Valori zero

Ogni tipo ha un valore zero, cioè ciò che contiene una variabile prima che tu le assegni qualcosa: 0 per i numeri, false per bool, "" per le stringhe e nil per puntatori, slice, mappe, channel, funzioni e interfacce. In Go non esistono variabili non inizializzate.