Comment compléter correctement les nombres avec des zéros en Go : guide de formatage

Problème éternel : « 0 » à gauche ou « décalage à droite » ?

Avez-vous déjà remarqué pourquoi dans les requêtes SQL les numéros de commande ressemblent à 00042, et dans les logs à 23:05:07 ? C'est simple : les nombres complétés par des zéros sont alignés en largeur et ne cassent pas le tri. Mais en Go, contrairement à Python ou JavaScript, il n'existe pas de méthode intégrée zfill. Et c'est là que les choses deviennent intéressantes.

Sur Stack Overflow, la question « How to pad a number with zeros when printing? » a recueilli des milliers de vues et des dizaines de réponses. Les gens cherchent non seulement une solution, mais une solution rapide. Dans cet article, nous allons passer en revue toutes les façons de compléter un nombre avec des zéros en Go, comparer leurs performances et choisir la meilleure pour votre projet.

Pourquoi est-ce important pour un développeur Go ?

Go est un langage de programmation système où chaque nanoseconde compte. Si vous écrivez un service à forte charge, un formatage incorrect des chaînes peut devenir un goulot d'étranglement. Surtout si vous formatez des milliers de nombres par seconde.

\n
• Journalisation : horodatages, ID de requêtes, codes d'erreur.
\n
• Génération de rapports : CSV, JSON, tableaux.
\n
• Protocoles réseau : longueur fixe des champs.
\n
• Jeux et graphismes : alignement du texte dans la console.
\n

Ignorer les performances peut conduire à ce que votre service passe 10 % de son temps à formater des nombres. Vous ne croyez pas ? Vérifions.

Méthode n°1 : La classique via fmt.Sprintf

La méthode la plus évidente et souvent recommandée est d'utiliser fmt.Sprintf avec le spécificateur de format %0Xd, où X est la largeur totale du nombre avec les zéros.

package main\n\nimport "fmt"\n\nfunc main() {\n    num := 42\n    padded := fmt.Sprintf("%05d", num)\n    fmt.Println(padded) // Sortie : 00042\n}\n

Ici, %05d signifie : « affiche le nombre comme un entier décimal, remplis à gauche avec des zéros jusqu'à une largeur de 5 caractères ». Si le nombre est déjà plus long (par exemple 123456), les zéros ne sont pas ajoutés — la largeur est ignorée.

Avantages :

\n
• Simple et lisible.
\n
• Prend en charge les nombres négatifs (le signe sera à gauche des zéros).
\n
• Fonctionne avec différents types : %05d pour int, %05.2f pour float.
\n

Inconvénients :

\n
• Utilise la réflexion en interne dans fmt — lent.
\n
• Crée une chaîne et un interface{} supplémentaires.
\n
• Ne convient pas aux chemins critiques.
\n

Méthode n°2 : strconv.FormatInt rapide avec complétion manuelle

Si les performances sont critiques, utilisez le package strconv. Il travaille directement avec les octets, sans réflexion.

package main\n\nimport (\n    "fmt"\n    "strconv"\n    "strings"\n)\n\nfunc padNumber(num int64, width int) string {\n    s := strconv.FormatInt(num, 10)\n    if len(s) >= width {\n        return s\n    }\n    return strings.Repeat("0", width-len(s)) + s\n}\n\nfunc main() {\n    fmt.Println(padNumber(42, 5)) // 00042\n}\n

Avantages :

\n
• 2 à 3 fois plus rapide que fmt.Sprintf.
\n
• Pas de réflexion.
\n
• Contrôle total sur la logique.
\n

Inconvénients :

\n
• Plus de code.
\n
• Nécessite de traiter les nombres négatifs séparément (signe à gauche des zéros).
\n
• strings.Repeat crée une nouvelle chaîne — on peut optimiser davantage.
\n

Méthode n°3 : Performances maximales via strings.Builder

Pour ceux qui veulent tirer le maximum, il existe une méthode sans allocations superflues — utiliser strings.Builder et allouer le tampon à l'avance.

package main\n\nimport (\n    "fmt"\n    "strconv"\n    "strings"\n)\n\nfunc padNumberFast(num int64, width int) string {\n    s := strconv.FormatInt(num, 10)\n    if len(s)