How to pad a number with zeros when printing?

Question

How can I print a number or make a string with zero padding to make it fixed width?

For instance, if I have the number 12 and I want to make it 000012.

score 319 · Answer 1 · edited Nov 04 '20 at 14:47

319

The fmt package can do this for you:

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

Output:

|000012|   345|

Notice the 0 in %06d, that will make it a width of 6 and pad it with zeros. The second one will pad with spaces.

Try it for yourself here: http://play.golang.org/p/cinDspMccp

edited Nov 04 '20 at 14:47

subtleseeker

4,415
5
29
41

answered Sep 03 '14 at 06:13

Travis Reeder

38,611
12
87
87

3

What if I want the pad to be to the right? using the flag `-` only gives spaces, I need zeros. – majidarif Feb 19 '17 at 06:43
15

If you want a string to later work with, use `Sprintf` instead of `Printf` – oliverpool Jan 22 '18 at 21:21
2

@majidarif padding with zeroes on the right turns 345 into 345000, which is kind of a different number. – hobbs Mar 17 '21 at 06:25
@hobbs right padding a hex string has its uses. Consider 4 bytes right-padded 0s (e.g. ip address of "C0" is "192.0.0.0") or 3 byte colors padded with the right most symbol (e.g. "FFF" is "FFFFFF" or 255 255 255 for white) – Josh Hibschman Nov 02 '21 at 17:02
@JoshHibschman if you want to compute a different, related value, you can do so, but it goes well beyond the kind of formatting that printf does. – hobbs Nov 02 '21 at 17:09

Christopher Oezbek · Answer 2 · 2020-11-06T20:51:50.107

Use the Printf function from the fmt package with a width of 6 and the padding character 0:

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

Setting the width works by putting an integer directly preceding the format specifier ('verb'):

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'

The only padding characters supported by Golang (and most other languages) are spaces and 0:

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

It is possible to right-justify the printing by prepending a minus -:

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

Beware that for floating point numbers the width includes the whole format string:

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

It is useful to note that the width can also be set programmatically by using * instead of a number and passing the width as an int parameter:

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

This might be useful for instance if the largest value you want to print is only known at runtime (called maxVal in the following example):

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

Last, if you don't want to print to stdout but return a String, use Sprintf also from fmt package with the same parameters:

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

That programmatic padding length is a gem, thank you! – unmultimedio Dec 24 '20 at 00:46 — unmultimedio, Dec 24 '20 at 00:46

score 39 · Answer 3 · answered Jan 04 '18 at 06:12

There is one simplest way to achieve this. Use

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

fmt.Sprintf formats and returns a string without printing it anywhere. Here %02d says pad zero on left for value who has < 2 number of digits. If given value has 2 or more digits it will not pad. For example:

If input is 1, output will be 01.
If input is 12, output will be 12.
If input is 1992, output will be 1992.

You can use %03d or more for more zeros padding.

score 13 · Answer 4 · edited Jul 07 '21 at 22:58

Just in case if you want to prefix or suffix to form another word by concatenating you can use below code.

package main

import "fmt"

func main() {
    concatenatedWord:= "COUNTER_"+fmt.Sprintf("%02d", 1)
    // use concatenatedWord 
        fmt.Println("ConcatenatedWordword is", concatenatedWord)
}

output : ConcatenatedWordword is COUNTER_01

link : https://play.golang.org/p/25g3L8TXiPP

VonC · Answer 5 · 2017-11-12T13:46:35.047

The question "List of printing format in Go lang" reminds us that there is also the flag:

- pad with spaces on the right rather than the left (left-justify the field)

You can see more padding examples with DaddyOh/golang-samples/pad.go, if you want to pad with other string sequences (more complex than '0' or ''):

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)

See 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

Eric Palmer removed his repo with golang samples so link isn't working anymore. — G07cha, Nov 12 '17 at 05:08
@KonstantinAzizov Good point. I have restored that link. Sort of. — VonC, Nov 12 '17 at 13:46

score 6 · Answer 6 · answered Aug 02 '17 at 09:21

6

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

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

answered Aug 02 '17 at 09:21

keyzi

69
1
1

Gillespie · Answer 7 · 2022-05-19T16:36:44.597

2

Here's my solution:

func leftZeroPad(number, padWidth int64) string {
    return fmt.Sprintf(fmt.Sprintf("%%0%dd", padWidth), number)
}

Example usage:

fmt.Printf("%v", leftZeroPad(12, 10))

prints:

0000000012

The advantage of this is that you can specify the pad length at run time if needed.

edited May 19 '22 at 16:36

answered May 12 '22 at 21:52

Gillespie

5,780
3
32
54

score 1 · Answer 8 · answered Sep 25 '20 at 21:49

For those that want to right pad, you can do this:

str2pad := "12"
padWith := "0"
amt2pad := 6

//This will make sure there is always 6 characters total, padded on the right side
//Note to check if strings.Repeat returns a negative value
paddedStr := str2pad + strings.Repeat(padWith, amt2pad - len(str2pad))

//Outputs 120000

Zombo · Answer 9 · 2021-07-07T16:24:29.837

1

Another option is the golang.org/x/text/number package:

package main

import (
   "golang.org/x/text/language"
   "golang.org/x/text/message"
   "golang.org/x/text/number"
)

var fmt = message.NewPrinter(language.English)

func main() {
   n := number.Decimal(
      12, number.Pad('0'), number.FormatWidth(6),
   )
   fmt.Println(n) // 000012
}

https://pkg.go.dev/golang.org/x/text/number

edited Jul 07 '21 at 16:24

answered Mar 06 '21 at 00:14

Zombo

1
62
391
407

score 0 · Answer 10 · edited Feb 23 '23 at 13:36

0

fmt.Printf("%012s", "345")

Result: 000000000345

edited Feb 23 '23 at 13:36

Neenad

861
5
19

answered Feb 16 '23 at 08:56

KucherRacer

1

How to pad a number with zeros when printing?

10 Answers10

Linked

Related