Formatage de chaînes en Go sans impression : guide complet

Introduction : Pourquoi formater une chaîne si on n'a pas besoin d'imprimer ?

Avez-vous déjà été confronté à une situation où vous devez joliment assembler une chaîne à partir de plusieurs parties, insérer des variables, ajouter des retraits, mais sans afficher le résultat à l'écran ? Il semble que tous les exemples dans les tutoriels Go se terminent par un appel à fmt.Println, mais que faire si la chaîne est nécessaire pour l'envoyer sur le réseau, l'écrire dans un fichier ou la passer à une autre fonction ?

Cette question tourmente des milliers de développeurs, et ce n'est pas pour rien — sur Stack Overflow, elle a recueilli des dizaines de milliers de vues. Dans cet article, nous allons voir comment formater des chaînes en Go sans impression, en utilisant des exemples de code réels. Vous découvrirez l'outil puissant fmt.Sprintf, les approches modernes avec strings.Builder et le bas niveau bytes.Buffer. C'est parti !

Problème : Printf imprime, mais j'ai besoin de sauvegarder

En Go, il existe une excellente fonction fmt.Printf qui formate une chaîne et l'affiche immédiatement dans le flux de sortie standard. Mais que faire si vous voulez obtenir la chaîne formatée comme une valeur, et non comme un effet secondaire ? Par exemple :

name := "Alice"age := 30// Je veux obtenir la chaîne "Je m'appelle Alice, j'ai 30 ans"// mais sans l'imprimer immédiatement

Les développeurs débutants écrivent souvent ceci :

fmt.Printf("Je m'appelle %s, j'ai %d ans", name, age)// La chaîne est imprimée, mais nous l'avons perdue !

Cela fonctionne, mais le résultat part dans la console. Alors que nous avons besoin de le sauvegarder dans une variable pour un traitement ultérieur. La solution existe, et elle est élégante.

Solution n°1 : fmt.Sprintf — le roi du formatage

Dans le package fmt, il existe une fonction jumelle de Printf appelée Sprintf. La lettre "S" au début signifie "String" — elle retourne une chaîne, ne l'imprime pas. C'est la manière la plus directe et la plus compréhensible de formater des chaînes en Go sans impression.

Exemple de base avec Sprintf

package main

import (    "fmt")

func main() {    name := "Bob"    age := 25    score := 98.5

    // Formatage sans impression    message := fmt.Sprintf("Bonjour, %s ! Tu as %d ans. Ton résultat : %.1f points.", name, age, score)

    // Maintenant, message contient la chaîne formatée    fmt.Println(message) // On imprime seulement maintenant}

Sortie :

Bonjour, Bob ! Tu as 25 ans. Ton résultat : 98.5 points.

Notez que Sprintf utilise les mêmes espaces réservés ( %s, %d, %f ) que Printf. La seule différence est que le résultat est retourné, et non affiché.

Espaces réservés avancés

Vous pouvez utiliser toutes les capacités de formatage de Go :

package main

import "fmt"

func main() {    // Alignement par largeur    leftAligned := fmt.Sprintf("%-10s %d", "Produit", 10)    rightAligned := fmt.Sprintf("%10s %d", "Produit", 10)

    // Formatage des nombres    price := 1234.5678    formattedPrice := fmt.Sprintf("Prix : $%.2f (avec TVA : $%.2f)", price, price*1.2)

    // Affichage hexadécimal    hexValue := fmt.Sprintf("Hex : %x, Dec : %d", 255, 255)

    fmt.Println(leftAligned)    fmt.Println(rightAligned)    fmt.Println(formattedPrice)    fmt.Println(hexValue)}

Sortie :

Produit   10   Produit 10Prix : $1234.57 (avec TVA : $1481.48)Hex : ff, Dec : 255

fmt.Sprintf est votre outil universel pour le formatage de chaînes Go. Il fonctionne rapidement, est compréhensible et couvre 90% des tâches.

Solution n°2 : strings.Builder — pour les constructions complexes

Que faire si vous devez assembler une chaîne à partir de nombreuses parties, en les ajoutant une par une ? Par exemple, générer du HTML, du JSON ou une requête SQL. Utiliser Sprintf pour chaque partie n'est pas efficace — vous allez co