Types de données en Golang : int, float64, string, bool, byte, rune

Les types de base de Go sont les nombres, les booléens et les chaînes. Chaque variable a exactement un type, fixé à la compilation, et Go ne convertit jamais entre types à votre place. %T affiche le type de n'importe quelle valeur :

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

Remarquez que 'G' s'affiche 71 avec le type int32 : un caractère entre apostrophes est une rune, c'est-à-dire un nombre (le point de code Unicode). rune est un alias de int32 (le même type sous un second nom), donc %T indique int32. De même, byte indique uint8.

Entiers

Utilisez int par défaut. len() renvoie un int, les indices de slice sont des int, et les compteurs de boucle sont des int. Sur toutes les plateformes 64 bits, int fait 64 bits. Tournez-vous vers les types à taille fixe quand la taille fait partie d'un contrat : int32 dans un format de fichier binaire, uint8 pour des octets bruts, int64 pour un timestamp Unix en nanosecondes.

Évitez les types non signés pour des quantités qui « ne peuvent pas être négatives », comme des comptes. Soustraire en dessous de zéro reboucle vers un nombre énorme au lieu de produire un négatif que vous pourriez détecter.

Limites et dépassement

Le package math a une constante pour chaque limite. À l'exécution, une opération entière qui dépasse reboucle silencieusement :

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

Pas de panic, pas d'erreur : 127 + 1 devient -128. Seules les expressions constantes sont vérifiées à la compilation (var b int8 = 128 ne compile pas). Si un dépassement est possible avec vos données, vérifiez avant l'opération ou utilisez math/big.

Littéraux entiers

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

Nombres à virgule flottante

Un littéral avec un point décimal ou un exposant (2.5, 1e6) est un float64 par défaut, et le package math prend et renvoie des float64. Utilisez-le sauf si la mémoire d'un gros tableau compte.

Les flottants sont binaires, donc la plupart des fractions décimales sont des approximations :

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

Deux règles en découlent. Ne comparez jamais des flottants avec == après un calcul. Et ne stockez jamais de l'argent dans un flottant : utilisez un nombre entier de centimes, ou une bibliothèque décimale.

Diviser un flottant par zéro donne +Inf, -Inf ou NaN au lieu de provoquer un panic. Diviser un entier par zéro provoque un panic à l'exécution (runtime error: integer divide by zero), et un diviseur constant nul est une erreur de compilation.

Booléens

bool contient true ou false, et sa valeur zéro est false. Go ne traite pas les nombres, les chaînes vides ou nil comme des booléens. if count {} est une erreur de compilation ; écrivez if count > 0 {}. Les opérateurs sont &&, || et !, et && et || s'évaluent en court-circuit.

Chaînes

Une string est une séquence immuable d'octets, généralement du texte UTF-8. len(s) compte les octets, pas les caractères :

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

é occupe deux octets en UTF-8, donc len indique 6 pour cinq caractères. Les chaînes entre guillemets doubles interprètent les échappements comme \n ; les chaînes brutes entre accents graves ne le font pas, et peuvent s'étendre sur plusieurs lignes. La page sur les chaînes couvre le package strings, et la page runes et octets traite UTF-8 en profondeur.

byte et rune

Ce sont des alias, pas de nouveaux types : un byte et un uint8 sont interchangeables sans conversion. Les noms disent ce que le nombre signifie.

Nombres complexes

Go a des types complexes intégrés, complex64 et complex128, avec real, imag et le 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))
}

Peu de programmes en ont besoin, mais le traitement du signal et certains codes numériques oui.

Types composites et types référence

Les types de base se combinent en types composites. Chacun a sa propre page :

any est un alias de interface{} (depuis Go 1.18) et peut contenir une valeur de n'importe quel type.

Types nommés

Vous pouvez définir un nouveau type à partir d'un type existant. Il a la même représentation mais c'est un type distinct, et il peut avoir des méthodes :

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

Cette rigueur est tout l'intérêt : un UserID ne peut pas être passé par erreur là où un OrderID est attendu. Convertissez explicitement quand c'est voulu : float64(t). Voir la conversion de types pour les règles et les fonctions strconv pour passer des nombres aux chaînes et inversement.

Valeurs zéro

Chaque type a une valeur zéro, que contient une variable avant toute affectation : 0 pour les nombres, false pour bool, "" pour les chaînes, et nil pour les pointeurs, slices, maps, channels, fonctions et interfaces. Il n'y a pas de variable non initialisée en Go.