Printf và Sprintf trong Golang: bảng verb của fmt

Package fmt có ba nhóm hàm in, và mỗi nhóm có cùng ba biến thể:

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 thêm dấu cách giữa các toán hạng và ký tự xuống dòng ở cuối. Printf không thêm gì: bạn tự viết \n. Print chỉ thêm dấu cách giữa hai toán hạng khi cả hai đều không phải chuỗi, một quy tắc đủ gây bất ngờ để hầu hết code dùng Println hoặc Printf.

Các verb định dạng

Tổng quát

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 là lựa chọn nên dùng khi gỡ lỗi. Một con trỏ tới struct được in ra dưới dạng &{...} thay vì một địa chỉ. Map được in với các khóa đã sắp xếp, nên đầu ra ổn định dù thứ tự duyệt map là ngẫu nhiên.

Số nguyên

Số thực

%.2f làm tròn giá trị nhị phân chính xác của số thực, nên fmt.Sprintf("%.2f", 2.675) cho ra 2.67: số float64 gần 2.675 nhất nhỏ hơn nó một chút. Đừng bao giờ định dạng tiền từ một số thực; hãy lưu số xu trong một số nguyên.

Chuỗi và byte

%s với một []byte in nó ra dưới dạng văn bản; %v in ra các con số ([104 105]).

Các kiểu khác

Độ rộng, độ chính xác và căn lề

Giữa % và verb, bạn có thể đặt flag, độ rộng và độ chính xác:

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

Lưu ý %.0f của 2.5 in ra 2: ở đây Go làm tròn nửa về số chẵn. Với chuỗi, độ rộng đếm theo rune chứ không theo cột hiển thị, nên ký tự CJK và emoji vẫn có thể làm lệch bảng. Để căn cột cho văn bản có độ dài thay đổi, text/tabwriter sẽ đo giúp bạn.

Chỉ số đối số

%[n] chọn một đối số theo vị trí, cho phép bạn dùng lại nó:

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

Errorf và %w

fmt.Errorf tạo một error từ chuỗi định dạng. Với %w, nó còn wrap một lỗi khác, để bên gọi vẫn phát hiện được lỗi gốc:

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

Dùng %w khi bên gọi có thể cần kiểm tra nguyên nhân, và %v khi bạn cố ý che giấu nó. Từ Go 1.20, một lời gọi Errorf có thể chứa nhiều verb %w. Trang xử lý lỗi trình bày chi tiết về việc wrap lỗi.

Tùy chỉnh định dạng với String()

Bất kỳ kiểu nào có phương thức String() string đều tự quyết định cách %v, %s và Println hiển thị nó:

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 bỏ qua String() và in ra con số bên dưới. Với các kiểu lỗi, phương thức tương ứng là Error() string, và nó được ưu tiên hơn String().

Khi verb bị sai

fmt không bao giờ panic khi gặp định dạng sai. Nó in vấn đề ngay tại chỗ:

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)

Kiểu đầu ra đó thường lọt được lên production vì nó không làm gì bị crash. go vet bắt được cả ba trường hợp lúc 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

Lưu ý về hiệu năng

fmt nhận mọi đối số dưới dạng any và kiểm tra kiểu lúc chạy (dùng reflection với struct, slice và map), điều này ổn cho việc ghi log và in đầu ra nhưng tốn thời gian đáng kể trong các vòng lặp chặt. Để chuyển đổi một con số đơn lẻ, strconv.Itoa và strconv.FormatFloat nhanh hơn Sprintf. Để xây dựng một chuỗi dài trong vòng lặp, hãy ghi vào một strings.Builder bằng fmt.Fprintf(&b, ...) thay vì nối các kết quả của Sprintf.