Formatted output with fmt: verbs and widths

A bill that prints Samosa 3 54.00 on one line and Filter coffee 1 40.50 on the next is hard to read; the same numbers in columns are not. Go’s fmt package writes such columns with a format string: %-14s puts a string left-aligned in 14 characters, %4d a number right-aligned in 4, and verbs like them decide how each value appears.

You will choose between Println, Printf and Sprintf, pick the verb that shows a value the way you need, and line up a table with widths and padding. The programs below ran on Go 1.27.1, and each shows what it printed.

Println, Printf and Sprintf differ in spaces, newlines and destination

The print functions come in families. Print and Println write their operands in their default format; Printf follows a format stringformat string: The first argument of Printf, Sprintf and their relatives: text in which each verb, such as %d or %s, marks where the next argument goes and how it is shown. The rest of the text is copied as it is.; the S versions return the text, and the F versions write to any destination that accepts bytes:

// print_funcs.go: where each print function puts its text, and its spaces.
package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	fmt.Print("total", 3, 4, "\n")    // a space only between two operands that are not strings
	fmt.Println("total", 3, 4)        // a space between all operands, then a newline
	fmt.Printf("total %d+%d\n", 3, 4) // a format string; the newline is yours to write

	line := fmt.Sprintf("%d items", 7) // returns the text instead of printing it
	fmt.Println(len(line), "bytes:", line)

	var b strings.Builder
	fmt.Fprintf(&b, "order %d", 15) // writes to any io.Writer
	fmt.Fprintln(os.Stdout, b.String())

	fmt.Println("total %d", 3) // Println prints a verb as it is
}

total3 4
total 3 4
total 3+4
7 bytes: 7 items
order 15
total %d 3

Print added a space only between 3 and 4, the two operands that are not strings, so total and 3 ran together. Println put a space between every operand and ended the line. Printf printed exactly what its format said, its newline included, and Sprintf returned a 7-byte string instead of printing it. Fprintf wrote into a strings.Builder; the same call writes to os.Stderr, a file or a network connection.

A verb chooses how each value is shown

In a format string, % and a letter form a verbverb: In a format string, a percent sign and a letter, such as %d, %s or %v, that takes the next argument and says how to show it. Flags, a width and a precision may stand between the two., and each verb takes the next argument. %v works for every type, which is why Println uses it. The others choose a view:

// verbs.go: one value, several verbs.
package main

import "fmt"

type Ticket struct {
	ID    int
	Route string
	Fare  float64
}

func main() {
	t := Ticket{ID: 42, Route: "Pune-Mumbai", Fare: 355.5}
	fmt.Printf("%v\n", t)
	fmt.Printf("%+v\n", t)
	fmt.Printf("%#v\n", t)
	fmt.Printf("%T\n", t)

	fmt.Printf("%d %s %q %t\n", 42, "seat", "seat 4", true)
	fmt.Printf("%x %X %o %b\n", 255, 255, 8, 5)
	fmt.Printf("%f %.2f %e %g\n", 355.5, 355.5, 355.5, 355.5)
	fmt.Printf("%c %U %q\n", '₹', '₹', '₹')
}

{42 Pune-Mumbai 355.5}
{ID:42 Route:Pune-Mumbai Fare:355.5}
main.Ticket{ID:42, Route:"Pune-Mumbai", Fare:355.5}
main.Ticket
42 seat "seat 4" true
ff FF 10 101
355.500000 355.50 3.555000e+02 355.5
₹ U+20B9 '₹'

%+v is the one to reach for when you debug a struct, because it names every field, and %#v prints text you can paste into a test. A type can also choose its own text for %v with a String method.

Width, precision and flags line up columns

Between % and the letter, a number sets the width, the least number of characters to fill, and a dot with a number sets the precision. Flags change the padding: - puts the spaces on the right, 0 pads numbers with zeros, + always shows a sign. Here the amounts stay in whole paise, hundredths of a rupee, and print through %d.%02d:

// invoice.go: columns lined up with widths, and rupees printed from paise.
package main

import "fmt"

type line struct {
	item  string
	qty   int
	paise int64 // the price of one, in paise (₹1 = 100 paise)
}

func main() {
	lines := []line{{"Masala chai", 2, 2500}, {"Samosa", 3, 1800}, {"Filter coffee", 1, 4050}}
	fmt.Printf("%-14s %4s %10s\n", "Item", "Qty", "Amount ₹")
	var total int64
	for _, l := range lines {
		amount := int64(l.qty) * l.paise
		total += amount
		fmt.Printf("%-14s %4d %7d.%02d\n", l.item, l.qty, amount/100, amount%100)
	}
	fmt.Printf("%-14s %4s %7d.%02d\n", "Total", "", total/100, total%100)
	fmt.Printf("[%6s] [%-6s] [%06d] [%+d]\n", "₹50", "₹50", 42, 42)
}

Item            Qty   Amount ₹
Masala chai       2      50.00
Samosa            3      54.00
Filter coffee     1      40.50
Total                   144.50
[   ₹50] [₹50   ] [000042] [+42]

Step through how Printf builds the Samosa line:

Every amount ends at the same column because %7d.%02d makes each amount here 10 characters wide, as wide as the header’s %10s. Width counts characters, not bytes: "₹50" is 5 bytes, yet %6s padded it with 3 spaces, which differs from C’s printf. For a float, %.2f keeps two digits after the point; for a string, precision cuts it.

Wrong verbs, missing arguments and go vet, reproduced Pro: opens with a Pro, Premium or Ultimate pass

Go syntax, argument indexes and String methods, measured Pro: opens with a Pro, Premium or Ultimate pass

Practise

Practice on the print functions, the verbs and the widths opens with whichever of the three your answers so far leave weakest, and every choice you pick is explained on the spot:

Interview questions

Warm-up (fresher): What is the difference between %v, %+v and %#v?

All three print a value. %v uses the default format, such as {42 Pune-Mumbai 355.5} for a struct. %+v adds the field names of structs, and %#v prints the value in Go syntax, with its type, which you could paste into code.

Three longer questions of the module bank build on this lesson:

Key takeaways

• Print adds spaces only between non-strings, Println always adds spaces and a newline, Printf follows its format string, Sprintf returns the text and Fprintf writes it to any writer.
• A verb takes the next argument: %v shows any value, %+v adds field names, %#v gives Go syntax and %T the type.
• A width is the least room a value takes, - aligns it left, 0 pads numbers with zeros, and precision sets the digits of a float or cuts a string.