Golang: Como preencher um número com zeros ao imprimir?

Como posso imprimir um número ou fazer uma string com preenchimento zero para torná-lo de largura fixa?

Por exemplo, se eu tiver o número 12e quiser fazê-lo 000012.

O pacote fmt pode fazer isso por você:

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

Observe o 0 em% 06d, que o tornará uma largura de 6 e o ​​preencherá com zeros. O segundo será preenchido com espaços.

Você pode vê-lo em ação aqui: http://play.golang.org/p/cinDspMccp

Use a Printffunção do pacote fmt com um widthde 6e o caractere de preenchimento 0:

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

Configurando as widthobras colocando um inteiro precedendo diretamente o especificador de formato ('verbo'):

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'

Os únicos caracteres de preenchimento suportados pelo Golang (e a maioria dos outros idiomas) são espaços e 0:

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

É possível justificar à direita a impressão adicionando um menos -:

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

Esteja ciente de que, para números de ponto flutuante, a largura inclui toda a string de formato:

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

É útil observar que a largura também pode ser definida de maneira programática usando em *vez de um número e passando a largura como um intparâmetro:

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

Isso pode ser útil, por exemplo, se o maior valor que você deseja imprimir só for conhecido no tempo de execução (chamado maxValno exemplo a seguir):

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

Por último, se você não quiser imprimir, stdoutmas retornar uma String, use Sprintftambém from fmt package com os mesmos parâmetros:

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

Existe uma maneira mais simples de conseguir isso. Usar

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

fmt.Sprintfformata e retorna uma string sem imprimi-la em qualquer lugar. Aqui %02ddiz o pad zero à esquerda para o valor que tem <2 números de dígitos. Se o valor fornecido tiver 2 ou mais dígitos, ele não será preenchido. Por exemplo:

• Se a entrada for 1, a saída será 01.
• Se a entrada for 12, a saída será 12.
• Se a entrada for 1992, a produção será 1992.

Você pode usar %03dou mais para mais preenchimento de zeros.

A pergunta " Lista de formatos de impressão em Go lang " nos lembra que também existe a bandeira:

- pad com espaços à direita em vez de à esquerda (justifique o campo à esquerda)

Você pode ver mais exemplos de preenchimento com DaddyOh/golang-samples/pad.go, se desejar preencher com outras sequências de strings (mais complexo do 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)

Veja 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) resultado: "03"

lpad ("12", "0", 6) resultado: "000012"