Go offre plusieurs méthodes efficaces pour convertir des entiers en leurs représentations sous forme de chaînes de caractères. Il s’agit d’une tâche courante lors de l’affichage de nombres, de la journalisation de données ou de la construction de chaînes à diverses fins. Cet article explore trois approches principales : l’utilisation de la fonction strconv.Itoa, de la fonction strconv.FormatInt et de la méthode fmt.Sprint.
Table des matières
Fonction strconv.Itoa
Pour convertir des entiers signés (int) en chaînes de caractères, strconv.Itoa fournit la solution la plus simple et la plus efficace. Elle prend directement un entier et renvoie son équivalent en chaîne de caractères. Bien que très fiable, une erreur potentielle (bien que rare) entraînera une panique.
package main
import (
"fmt"
"strconv"
)
func main() {
num := 12345
str := strconv.Itoa(num)
fmt.Println(str) // Sortie : 12345
negativeNum := -9876
negativeStr := strconv.Itoa(negativeNum)
fmt.Println(negativeStr) // Sortie : -9876
}
Sa concision et sa vitesse la rendent idéale pour les conversions d’entiers signés simples.
Fonction strconv.FormatInt
strconv.FormatInt offre une plus grande flexibilité, prenant en charge différentes tailles d’entiers (int64, int32, etc.) et permettant de spécifier la base (radix) de la chaîne de sortie. Cette fonctionnalité est particulièrement utile pour représenter les nombres en formats binaire, octal ou hexadécimal.
package main
import (
"fmt"
"strconv"
)
func main() {
num := int64(12345)
str := strconv.FormatInt(num, 10) // Base 10 (décimal)
fmt.Println(str) // Sortie : 12345
hexStr := strconv.FormatInt(num, 16) // Base 16 (hexadécimal)
fmt.Println(hexStr) // Sortie : 3039
binStr := strconv.FormatInt(num, 2) // Base 2 (binaire)
fmt.Println(binStr) // Sortie : 11000000111001
unsignedNum := uint64(12345)
unsignedStr := strconv.FormatUint(unsignedNum, 10)
fmt.Println(unsignedStr) //Sortie: 12345
}
Le deuxième argument définit la base (10 pour décimal, 16 pour hexadécimal, 2 pour binaire, 8 pour octal). Pour les entiers non signés, utilisez strconv.FormatUint.
Méthode fmt.Sprint
La fonction fmt.Sprint fournit une solution polyvalente pour convertir divers types de données, y compris les entiers, en chaînes de caractères. Bien que moins efficace que strconv.Itoa pour les conversions d’entiers simples, sa polyvalence est mise en évidence lors de la mise en forme simultanée de plusieurs valeurs.
package main
import (
"fmt"
)
func main() {
num := 12345
str := fmt.Sprint(num)
fmt.Println(str) // Sortie : 12345
str2 := fmt.Sprintf("Le nombre est : %d", num) // Plus de contrôle sur la mise en forme
fmt.Println(str2) // Sortie : Le nombre est : 12345
multipleValues := fmt.Sprint("Valeur1: ", 10, ", Valeur2: ", 20)
fmt.Println(multipleValues) // Sortie: Valeur1: 10, Valeur2: 20
}
fmt.Sprint est particulièrement utile pour intégrer des entiers dans des chaînes plus longues. fmt.Sprintf offre un contrôle plus précis sur la mise en forme à l’aide de spécificateurs de format (comme %d pour les entiers décimaux).
En résumé, strconv.Itoa est la meilleure solution pour les conversions simples d’entiers signés ; strconv.FormatInt (et strconv.FormatUint) permet de contrôler la base et gère différentes tailles d’entiers ; et fmt.Sprint et fmt.Sprintf offrent une plus grande flexibilité, mais peuvent être moins efficaces pour les conversions de base entier-chaîne. Choisissez la méthode qui correspond le mieux à vos besoins et à votre style de codage.