Golang Printf ve Sprintf: fmt Format Verb'leri Kopya Kağıdı

fmt paketinde üç yazdırma fonksiyonu ailesi vardır ve her ailenin aynı üç çeşidi bulunur:

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 işlenenler arasına boşluk, sonuna da yeni satır ekler. Printf hiçbir şey eklemez: \n'i kendiniz yazarsınız. Print yalnızca ikisi de string olmayan işlenenlerin arasına boşluk ekler; bu o kadar şaşırtıcıdır ki çoğu kod Println ya da Printf kullanır.

Format Verb'leri

Genel

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

Hata ayıklarken başvurulacak verb %+v'dir. Bir struct'a işaret eden pointer bir adres yerine &{...} olarak yazdırılır. Map'ler anahtarları sıralanmış olarak yazdırılır, bu yüzden map dolaşma sırası rastgele olsa da çıktı kararlıdır.

Tam sayılar

Float'lar

%.2f, float'ın kesin ikili değerini yuvarlar, bu yüzden fmt.Sprintf("%.2f", 2.675) sonucu 2.67'dir: 2.675'e en yakın float64 ondan biraz küçüktür. Parayı asla bir float'tan biçimlendirmeyin; kuruşları bir tam sayıda tutun.

String'ler ve byte'lar

Bir []byte üzerinde %s onu metin olarak yazdırır; %v ise sayıları yazdırır ([104 105]).

Diğer tipler

Genişlik, Hassasiyet ve Dolgu

% ile verb arasına bayraklar, bir genişlik ve bir hassasiyet koyabilirsiniz:

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

2.5 için %.0f'nin 2 yazdırdığına dikkat edin: Go burada yarımları çift sayıya yuvarlar. Genişlik, string'ler için ekran sütunlarını değil rune'ları sayar, bu yüzden CJK karakterleri ve emoji bir tabloyu yine de kaydırabilir. Değişken metinli hizalı sütunlar için ölçümü text/tabwriter sizin yerinize yapar.

Argüman indeksleri

%[n] bir argümanı konumuna göre seçer, bu da bir argümanı yeniden kullanmanızı sağlar:

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

Errorf ve %w

fmt.Errorf bir format string'inden bir error oluşturur. %w ile ayrıca başka bir hatayı sarmalar, böylece çağıranlar orijinali hâlâ tespit edebilir:

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

Çağıranların nedeni kontrol etmesi gerekebilecekse %w, nedeni bilerek gizliyorsanız %v kullanın. Go 1.20'den beri tek bir Errorf çağrısı birden fazla %w verb'ü içerebilir. Hata yönetimi sayfası sarmalamayı derinlemesine anlatıyor.

String() ile Özel Biçimlendirme

String() string metodu olan her tip, %v, %s ve Println'in onu nasıl göstereceğini kontrol eder:

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()'i atlar ve temeldeki sayıyı yazdırır. Hata tipleri için eşdeğer metot Error() string'dir ve String()'den önceliklidir.

Verb Yanlış Olduğunda

fmt hatalı bir biçimde asla panic yapmaz. Sorunu satır içinde yazdırır:

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)

Bu çıktı hiçbir şeyi çökertmediği için production'a kadar ulaşma eğilimindedir. go vet üçünü de derleme zamanında yakalar:

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

Performans Notları

fmt her argümanı bir any olarak alır ve tipini çalışma zamanında inceler (struct'lar, slice'lar ve map'ler için reflection'a başvurur); bu, loglama ve çıktı için sorun değildir ama sıkı döngülerde ölçülebilir bir maliyettir. Tek bir sayıyı dönüştürmek için strconv.Itoa ve strconv.FormatFloat, Sprintf'ten daha hızlıdır. Bir döngüde uzun bir string oluşturmak için Sprintf sonuçlarını birleştirmek yerine fmt.Fprintf(&b, ...) ile bir strings.Builder'a yazın.