Int en string, string en int et conversion de types en Golang

Go ne convertit jamais les types implicitement. Vous convertissez entre types compatibles avec T(v), et entre nombres et texte avec le package strconv. Les deux conversions les plus recherchées :

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 ») formate un int en texte décimal. strconv.Atoi (« ASCII to integer ») analyse du texte en int et renvoie une erreur quand le texte n'est pas un nombre valide. Vérifiez toujours cette erreur.

La conversion T(v)

La syntaxe de conversion de Go ressemble à un appel de fonction portant le nom du type cible. Elle fonctionne dans trois situations :

1. entre types numériques (int, int64, float64, uint8, ...),
2. entre string et []byte ou []rune,
3. entre types qui partagent un type sous-jacent (Celsius et 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)
}

Lisez attentivement les résultats :

• int(3.9) vaut 3 et int(-3.9) vaut -3. La conversion tronque vers zéro ; elle n'arrondit pas. Utilisez d'abord math.Round, math.Floor ou math.Ceil pour choisir le comportement. math.Round arrondit les demis en s'éloignant de zéro, donc -3.5 devient -4.
• uint8(300) vaut 44, parce que seuls les 8 bits de poids faible survivent (300 moins 256), et int8(200) vaut -56 pour la même raison. Pas d'erreur, pas de panic.
• Celsius et float64 partagent un type sous-jacent, donc ils se convertissent librement, mais seulement explicitement.

Les valeurs sont dans des variables exprès. Avec des constantes, les mêmes conversions ne compilent pas.

Les constantes sont vérifiées, les variables non

Convertir une constante qui ne tient pas dans le type est une erreur de compilation. Convertir une variable de même valeur reboucle silencieusement :

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

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

Convertir une constante non entière vers un type entier est aussi refusé, alors que la même valeur dans une variable est tronquée :

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

Si la valeur flottante est hors de la plage du type entier cible (par exemple int64(1e20)), le résultat dépend de l'implémentation : amd64 et arm64, par exemple, donnent des réponses différentes. Vérifiez la plage avant de convertir des valeurs non fiables.

Convertir des nombres en chaînes

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 prend un octet de format ('f' pour la notation fixe, 'e' pour l'exposant, 'g' pour la plus courte des deux), une précision (-1 signifie « le moins de chiffres possible pour un aller-retour exact »), et la taille en bits du flottant d'origine (64 ou 32).

strconv est plus rapide que fmt.Sprint, qui emballe la valeur dans une interface et passe par le chemin de formatage général de fmt. Dans une boucle critique, cette différence se voit ; pour des conversions occasionnelles, prenez ce qui se lit le mieux.

Convertir des chaînes en nombres

ParseInt renvoie toujours un int64. L'argument bitSize (0, 8, 16, 32, 64) fixe la plage acceptée, donc le résultat est garanti de tenir quand vous le convertissez vers un type plus petit. Une base de 0 signifie « déduire du préfixe », donc 0x1f, 0o17, 0b101 et 1_000 sont tous analysés.

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

Ce que montre la sortie :

• " 42" échoue. Atoi accepte un signe facultatif et des chiffres, rien d'autre. Une entrée lue avec bufio se termine généralement par \n, donc retirez-le.
• "4.2" est invalide pour Atoi. Utilisez ParseFloat pour les décimaux.
• Sur une erreur de dépassement, ParseInt renvoie la plus grande valeur qui tient (127 pour int8) avec l'erreur. N'utilisez pas la valeur quand l'erreur n'est pas nil.
• Les erreurs sont des valeurs *strconv.NumError qui enveloppent strconv.ErrSyntax ou strconv.ErrRange, donc errors.Is peut les distinguer.

ParseBool accepte 1, t, T, TRUE, true, True et les formes fausses correspondantes. "yes" et "on" sont des erreurs.

Le piège de string(65)

Convertir un entier en string ne produit pas de chiffres. Cela produit le caractère de ce point de code Unicode :

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

Le compilateur l'accepte, mais go vet le signale :

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

Si vous voulez vraiment le caractère, dites-le avec une rune : string(rune(n)). Si vous voulez le nombre sous forme de texte, utilisez strconv.Itoa(n). Convertir une rune ou un byte en string est correct et courant :

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
}

Chaînes, octets et runes

string, []byte et []rune se convertissent les uns dans les autres avec T(v). Chaque conversion copie les données, parce que les chaînes sont immuables et que les slices ne le sont pas :

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
}

Convertissez en []rune quand vous devez indexer ou modifier par caractère ; convertissez en []byte pour les E/S, le hachage et les modifications au niveau des octets. La page runes et octets détaille l'UTF-8.

Conversion ou assertion de type

Une conversion fait passer une valeur d'un type concret à un autre. Récupérer la valeur concrète d'une interface (any, error, io.Reader) est une opération différente, l'assertion de type :

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

Faites d'abord l'assertion, puis convertissez. La forme comma-ok n, ok := v.(int) évite un panic quand le type est faux.

Référence rapide

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