Golang: Comment remplir un nombre avec des zéros lors de l'impression?

Comment puis-je imprimer un nombre ou créer une chaîne avec un remplissage nul pour la rendre de largeur fixe?

Par exemple, si j'ai le numéro 12et que je veux le faire 000012.

Le package fmt peut le faire pour vous:

fmt.Printf("|%06d|%6d|\n", 12, 345)

Remarquez le 0 dans% 06d, qui lui donnera une largeur de 6 et le remplira de zéros. Le second remplira d'espaces.

Vous pouvez le voir en action ici: http://play.golang.org/p/cinDspMccp

Utilisez la Printffonction du package fmt avec un widthof 6et le caractère de remplissage 0:

import "fmt"
fmt.Printf("%06d", 12) // Prints to stdout '000012'

Définition des widthœuvres en mettant un entier directement précédant le spécificateur de format ('verbe'):

fmt.Printf("%d", 12)   // Uses default width,                          prints '12'
fmt.Printf("%6d", 12)  // Uses a width of 6 and left pads with spaces, prints '    12'

Les seuls caractères de remplissage pris en charge par Golang (et la plupart des autres langues) sont des espaces et 0:

fmt.Printf("%6d", 12)   // Default padding is spaces, prints '    12'
fmt.Printf("%06d", 12)  // Change to 0 padding,       prints '000012'

Il est possible de justifier correctement l'impression en ajoutant un signe moins -:

fmt.Printf("%-6d", 12)   // Padding right-justified, prints '12    '

Attention, pour les nombres à virgule flottante, la largeur inclut toute la chaîne de format:

fmt.Printf("%6.1f", 12.0) // Prints '0012.0' (width is 6, precision is 1 digit)

Il est utile de noter que la largeur peut également être définie par programme en utilisant à la *place d'un nombre et en passant la largeur comme intparamètre:

myWidth := 6
fmt.Printf("%0*d", myWidth, 12) // Prints '000012' as before

Cela peut être utile par exemple si la plus grande valeur que vous souhaitez imprimer n'est connue qu'au moment de l'exécution (appelée maxValdans l'exemple suivant):

myWidth := 1 + int(math.Log10(float64(maxVal)))
fmt.Printf("%*d", myWidth, nextVal)

Enfin, si vous ne souhaitez pas imprimer stdoutmais renvoyer une chaîne, utilisez Sprintfégalement le package fmt avec les mêmes paramètres:

s := fmt.Sprintf("%06d", 12) // returns '000012' as a String

Il existe un moyen le plus simple d'y parvenir. Utilisation

func padNumberWithZero(value uint32) string {
    return fmt.Sprintf("%02d", value)
}

fmt.Sprintfformate et renvoie une chaîne sans l'imprimer nulle part. Ici %02ddit pad zéro à gauche pour la valeur qui a <2 nombres de chiffres. Si la valeur donnée comporte 2 chiffres ou plus, elle ne sera pas complétée. Par exemple:

• Si l'entrée est 1, la sortie sera 01.
• Si l'entrée est 12, la sortie sera 12.
• Si l'entrée est 1992, la sortie sera 1992.

Vous pouvez utiliser %03dou plus pour plus de zéros.

La question " Liste des formats d'impression en Go lang " nous rappelle qu'il y a aussi le drapeau:

- pad avec des espaces à droite plutôt qu'à gauche (justifiez le champ à gauche)

Vous pouvez voir plus d'exemples de remplissage avec DaddyOh/golang-samples/pad.go, si vous souhaitez compléter avec d'autres séquences de chaînes (plus complexes que « 0» ou « »):

• leftPad(s string, padStr string, pLen int)
• rightPad(s string, padStr string, pLen int)
• leftPad2Len(s string, padStr string, overallLen int)
• rightPad2Len(s string, padStr string, overallLen int)

Voir play.golang.org:

1234567890

leftPad(str, "*", 3)  ***1234567890
leftPad2Len(str, "*-", 13)  -*-1234567890
leftPad2Len(str, "*-", 14)  *-*-1234567890
leftPad2Len(str, "*", 14)  ****1234567890
leftPad2Len(str, "*-x", 14)  x*-x1234567890
leftPad2Len(str, "ABCDE", 14)  BCDE1234567890
leftPad2Len(str, "ABCDE", 4)  7890
rightPad(str, "*", 3)  1234567890***
rightPad(str, "*!", 3)  1234567890*!*!*!
rightPad2Len(str, "*-", 13)  1234567890*-*
rightPad2Len(str, "*-", 14)  1234567890*-*-
rightPad2Len(str, "*", 14)  1234567890****
rightPad2Len(str, "*-x", 14)  1234567890*-x*
rightPad2Len(str, "ABCDE", 14)  1234567890ABCD
rightPad2Len(str, "ABCDE", 4)  1234

func lpad(s string,pad string, plength int)string{
    for i:=len(s);i<plength;i++{
        s=pad+s
    }
    return s
}

lpad ("3", "0", 2) résultat: "03"

lpad ("12", "0", 6) résultat: "000012"