Printf dan Sprintf di Golang: Cheat Sheet Format Verb fmt

Package fmt punya tiga keluarga fungsi cetak, dan setiap keluarga punya tiga varian yang sama:

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 menambahkan spasi di antara operand dan baris baru di akhir. Printf tidak menambahkan apa-apa: kamu sendiri yang menulis \n. Print menambahkan spasi hanya di antara operand yang keduanya bukan string, dan itu cukup mengejutkan sehingga kebanyakan kode memakai Println atau Printf.

Format Verb

Umum

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 adalah pilihan utama saat debugging. Pointer ke struct dicetak sebagai &{...}, bukan alamat. Map dicetak dengan key yang terurut, jadi output-nya stabil meskipun urutan iterasi map acak.

Integer

Float

%.2f membulatkan nilai biner eksak dari float itu, jadi fmt.Sprintf("%.2f", 2.675) menghasilkan 2.67: float64 terdekat dengan 2,675 sedikit lebih kecil dari angka itu. Jangan pernah memformat uang dari float; simpan sen dalam integer.

String dan byte

%s pada []byte mencetaknya sebagai teks; %v mencetak angka-angkanya ([104 105]).

Tipe lain

Width, Presisi, dan Padding

Di antara % dan verb, kamu bisa menaruh flag, width, dan presisi:

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)
	}
}

Perhatikan bahwa %.0f dari 2.5 mencetak 2: di sini Go membulatkan setengah ke angka genap. Width menghitung rune untuk string, bukan kolom tampilan, jadi karakter CJK dan emoji masih bisa membuat tabel tidak rata. Untuk kolom teks dengan panjang yang berbeda-beda, text/tabwriter melakukan pengukurannya untukmu.

Indeks argumen

%[n] memilih argumen berdasarkan posisinya, sehingga kamu bisa memakai satu argumen berulang kali:

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

Errorf dan %w

fmt.Errorf membuat error dari string format. Dengan %w, fungsi ini juga membungkus error lain, sehingga pemanggil masih bisa mendeteksi error aslinya:

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))
}

Pakai %w saat pemanggil mungkin perlu memeriksa penyebabnya, dan %v saat kamu sengaja menyembunyikannya. Sejak Go 1.20, satu pemanggilan Errorf boleh berisi beberapa verb %w. Halaman penanganan error membahas wrapping secara mendalam.

Format Kustom dengan String()

Tipe apa pun yang punya method String() string mengatur cara %v, %s, dan Println menampilkannya:

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 melewati String() dan mencetak angka di baliknya. Untuk tipe error, method yang setara adalah Error() string, yang lebih diutamakan daripada String().

Saat Verb-nya Salah

fmt tidak pernah panic karena format yang salah. Ia mencetak masalahnya di tempat:

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)

Output seperti itu cenderung lolos sampai ke produksi karena tidak membuat apa pun crash. go vet menangkap ketiganya saat 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

Catatan Performa

fmt menerima setiap argumen sebagai any dan memeriksa tipenya saat program berjalan (memakai reflection untuk struct, slice, dan map), dan itu tidak masalah untuk logging dan output, tetapi terasa di loop yang ketat. Untuk mengonversi satu angka, strconv.Itoa dan strconv.FormatFloat lebih cepat dari Sprintf. Untuk membangun string panjang di dalam loop, tulis ke strings.Builder dengan fmt.Fprintf(&b, ...) alih-alih menyambung hasil-hasil Sprintf.