Printf e Sprintf in Golang: guida ai verbi di formato di fmt

Il package fmt ha tre famiglie di funzioni di stampa, e ogni famiglia ha le stesse tre varianti:

package main

import (
	"fmt"
	"os"
)

func main() {
	name, score := "Ana", 92.456

	fmt.Println("Player", name, "scored", score)
	fmt.Printf("Player %s scored %.1f\n", name, score)

	msg := fmt.Sprintf("%s: %.0f points", name, score)
	fmt.Println(msg, len(msg))

	fmt.Fprintf(os.Stdout, "%-6s|%6.2f|\n", name, score)

	err := fmt.Errorf("player %q not found", "Ben")
	fmt.Println(err)
}

Println aggiunge spazi tra gli operandi e un a capo alla fine. Printf non aggiunge nulla: il \n lo scrivi tu. Print aggiunge spazi solo tra operandi che non sono entrambi stringhe, un comportamento abbastanza sorprendente da spingere la maggior parte del codice a usare Println o Printf.

Verbi di formato

Generali

package main

import "fmt"

type User struct {
	Name string
	Age  int
	Tags []string
}

func main() {
	u := User{Name: "Ana", Age: 31, Tags: []string{"admin"}}

	fmt.Printf("%v\n", u)
	fmt.Printf("%+v\n", u)
	fmt.Printf("%#v\n", u)
	fmt.Printf("%T\n", u)
	fmt.Printf("%v\n", &u)

	m := map[string]int{"b": 2, "a": 1}
	fmt.Printf("%v %#v\n", m, m)
}

%+v è quello da usare durante il debug. Un puntatore a una struct viene stampato come &{...} invece che come indirizzo. Le mappe vengono stampate con le chiavi ordinate, quindi l'output è stabile anche se l'ordine di iterazione delle mappe è casuale.

Interi

Float

%.2f arrotonda il valore binario esatto del float, quindi fmt.Sprintf("%.2f", 2.675) dà 2.67: il float64 più vicino a 2,675 è leggermente inferiore. Non formattare mai importi di denaro a partire da un float; tieni i centesimi in un intero.

Stringhe e byte

%s su un []byte lo stampa come testo; %v stampa i numeri ([104 105]).

Altri tipi

Larghezza, precisione e riempimento

Tra % e il verbo puoi mettere flag, una larghezza e una precisione:

package main

import "fmt"

func main() {
	fmt.Printf("|%5d|%-5d|%05d|\n", 42, 42, 42)
	fmt.Printf("|%8.2f|%-8.2f|%.0f|\n", 3.14159, 3.14159, 2.5)
	fmt.Printf("|%10s|%-10s|%.3s|\n", "gopher", "gopher", "gopher")
	fmt.Printf("|%+d|%+d|\n", 5, -5)
	fmt.Printf("|%*d|\n", 7, 42) // width from an argument

	fmt.Println()
	items := []struct {
		name  string
		price float64
	}{{"Keyboard", 49.9}, {"Mouse", 19.5}, {"Monitor", 229}}
	for _, it := range items {
		fmt.Printf("%-10s %8.2f\n", it.name, it.price)
	}
}

Nota che %.0f di 2.5 stampa 2: qui Go arrotonda la metà al numero pari. Per le stringhe la larghezza conta le rune, non le colonne visualizzate, quindi i caratteri CJK e le emoji possono comunque disallineare una tabella. Per colonne allineate di testo variabile, text/tabwriter fa le misure al posto tuo.

Indici degli argomenti

%[n] sceglie un argomento in base alla posizione, il che ti permette di riusarlo:

fmt.Printf("%[2]s %[1]s\n", "world", "hello") // hello world
fmt.Printf("%d %[1]x %[1]b\n", 10)             // 10 a 1010

Errorf e %w

fmt.Errorf costruisce un error a partire da una stringa di formato. Con %w avvolge anche un altro errore, così i chiamanti possono ancora riconoscere l'originale:

package main

import (
	"errors"
	"fmt"
	"os"
)

func loadConfig(path string) error {
	_, err := os.Open(path)
	if err != nil {
		return fmt.Errorf("load config %s: %w", path, err)
	}
	return nil
}

func main() {
	err := loadConfig("/no/such/file.yaml")
	fmt.Println(err)
	fmt.Println("not exist?", errors.Is(err, os.ErrNotExist))

	// %v formats the same text but does not wrap
	flat := fmt.Errorf("load config: %v", os.ErrNotExist)
	fmt.Println("wrapped?", errors.Is(flat, os.ErrNotExist))
}

Usa %w quando i chiamanti potrebbero dover controllare la causa, e %v quando vuoi nasconderla di proposito. Da Go 1.20 una chiamata a Errorf può contenere più verbi %w. La pagina sulla gestione degli errori approfondisce il wrapping.

Formattazione personalizzata con String()

Qualsiasi tipo con un metodo String() string controlla come lo mostrano %v, %s e Println:

package main

import "fmt"

type Money int64 // cents

func (m Money) String() string {
	return fmt.Sprintf("$%d.%02d", m/100, m%100)
}

func main() {
	price := Money(129950)
	fmt.Println(price)
	fmt.Printf("%v | %s | %d\n", price, price, price)
}

%d scavalca String() e stampa il numero sottostante. Per i tipi di errore il metodo equivalente è Error() string, che ha la precedenza su String().

Quando il verbo è sbagliato

fmt non va mai in panic per un formato errato. Stampa il problema direttamente nel testo:

fmt.Printf("%d\n", "oops")
fmt.Printf("%d %d\n", 1)
fmt.Printf("%d\n", 1, 2)

%!d(string=oops)
1 %!d(MISSING)
1
%!(EXTRA int=2)

Questo output tende ad arrivare in produzione perché non fa crashare nulla. go vet li rileva tutti e tre durante la build:

./main.go:8:2: fmt.Printf format %d has arg "oops" of wrong type string
./main.go:9:2: fmt.Printf format %d reads arg #2, but call has 1 arg
./main.go:10:2: fmt.Printf call needs 1 arg but has 2 args

Note sulle prestazioni

fmt riceve ogni argomento come any ed esamina il suo tipo durante l'esecuzione (ricorrendo alla reflection per struct, slice e mappe), il che va bene per i log e l'output ma si nota nei cicli stretti. Per convertire un singolo numero, strconv.Itoa e strconv.FormatFloat sono più veloci di Sprintf. Per costruire una stringa lunga in un ciclo, scrivi in uno strings.Builder con fmt.Fprintf(&b, ...) invece di concatenare i risultati di Sprintf.