Printf ו-Sprintf ב-Golang: דף עזר ל-verbs של fmt

לחבילת fmt יש שלוש משפחות של פונקציות הדפסה, ולכל משפחה אותן שלוש גרסאות:

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 מוסיפה רווחים בין האופרנדים ושורה חדשה בסוף. Printf לא מוסיפה כלום: את \n כותבים בעצמכם. Print מוסיפה רווחים רק בין אופרנדים ששניהם אינם מחרוזות, וזה מפתיע מספיק כדי שרוב הקוד ישתמש ב-Println או ב-Printf.

Format verbs

כלליים

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 הוא זה שכדאי להשתמש בו בדיבוג. מצביע ל-struct מודפס כ-&{...} ולא ככתובת. maps מודפסים עם מפתחות ממוינים, כך שהפלט יציב גם אם סדר המעבר על map אקראי.

מספרים שלמים

מספרים עשרוניים

%.2f מעגל את הערך הבינארי המדויק של ה-float, ולכן fmt.Sprintf("%.2f", 2.675) הוא 2.67: ה-float64 הקרוב ביותר ל-2.675 קטן ממנו במעט. אף פעם אל תעצבו כסף מ-float; שמרו אגורות במספר שלם.

מחרוזות ובתים

%s על []byte מדפיס אותו כטקסט; %v מדפיס את המספרים ([104 105]).

טיפוסים אחרים

רוחב, דיוק וריפוד

בין % ל-verb אפשר לשים דגלים, רוחב ודיוק:

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

שימו לב ש-%.0f של 2.5 מדפיס 2: כאן Go מעגלת חצי למספר הזוגי. במחרוזות, הרוחב סופר runes ולא עמודות תצוגה, כך שתווי CJK ואימוג'י עדיין יכולים לשבש את היישור של טבלה. לעמודות מיושרות של טקסט באורך משתנה, text/tabwriter עושה את המדידה בשבילכם.

אינדקסים של ארגומנטים

%[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 ו-%w

fmt.Errorf בונה error ממחרוזת פורמט. עם %w היא גם עוטפת שגיאה אחרת, כך שמי שקורא עדיין יכול לזהות את המקורית:

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

השתמשו ב-%w כשמי שקורא עשוי להצטרך לבדוק את הסיבה, וב-%v כשאתם מסתירים אותה בכוונה. החל מ-Go 1.20 קריאה אחת ל-Errorf יכולה להכיל כמה verbs של %w. הדף על טיפול בשגיאות מסביר עטיפה לעומק.

עיצוב מותאם עם String()

כל טיפוס עם מתודת String() string קובע איך %v, %s ו-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 עוקף את String() ומדפיס את המספר שמתחת. עבור טיפוסי שגיאה המתודה המקבילה היא Error() string, והיא קודמת ל-String().

כשה-verb שגוי

fmt אף פעם לא נכנסת ל-panic בגלל פורמט שגוי. היא מדפיסה את הבעיה בתוך הפלט:

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)

פלט כזה נוטה להגיע ל-production, כי הוא לא מפיל כלום. go vet תופס את שלושת המקרים בזמן הבנייה:

./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

הערות על ביצועים

fmt מקבלת כל ארגומנט כ-any ובוחנת את הטיפוס שלו בזמן ריצה (ונופלת חזרה ל-reflection עבור structs, slices ו-maps), וזה בסדר ללוגים ולפלט אבל מורגש בלולאות צפופות. להמרת מספר בודד, strconv.Itoa ו-strconv.FormatFloat מהירות יותר מ-Sprintf. לבניית מחרוזת ארוכה בלולאה, כתבו לתוך strings.Builder עם fmt.Fprintf(&b, ...) במקום לשרשר תוצאות של Sprintf.