Golang Printf와 Sprintf: 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를 씁니다.

포맷 동사

일반

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입니다. 구조체 포인터는 주소가 아니라 &{...}로 출력됩니다. 맵은 키를 정렬해서 출력하므로, 맵 순회 순서가 무작위여도 출력은 안정적입니다.

정수

실수

%.2f는 실수의 정확한 이진 값을 반올림하므로 fmt.Sprintf("%.2f", 2.675)는 2.67입니다. 2.675에 가장 가까운 float64가 그보다 조금 작기 때문입니다. 돈을 실수로 형식화하지 마세요. 센트를 정수로 보관하세요.

문자열과 바이트

[]byte에 %s를 쓰면 텍스트로 출력되고, %v를 쓰면 숫자([104 105])로 출력됩니다.

그 밖의 타입

너비, 정밀도, 채우기

%와 동사 사이에 플래그, 너비, 정밀도를 넣을 수 있습니다:

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에 %.0f를 쓰면 2가 출력된다는 점에 주의하세요. 여기서 Go는 오사오입(가장 가까운 짝수로 반올림)을 합니다. 문자열의 너비는 화면 칸이 아니라 룬 개수를 세므로, 한글, 한자, 이모지가 섞이면 표가 여전히 어긋날 수 있습니다. 길이가 제각각인 텍스트로 열을 맞추려면 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 호출 하나에 %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()보다 우선합니다.

동사가 틀렸을 때

fmt는 잘못된 형식에 절대 패닉을 일으키지 않습니다. 문제를 그 자리에 출력합니다:

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)

아무것도 죽이지 않기 때문에 이런 출력은 운영 환경까지 가기 쉽습니다. 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로 받아 런타임에 타입을 살펴보므로(구조체, 슬라이스, 맵은 리플렉션으로 처리), 로깅과 출력에는 괜찮지만 빡빡한 반복문에서는 비용이 눈에 띕니다. 숫자 하나를 변환할 때는 strconv.Itoa와 strconv.FormatFloat가 Sprintf보다 빠릅니다. 반복문에서 긴 문자열을 만들 때는 Sprintf 결과를 이어 붙이지 말고 fmt.Fprintf(&b, ...)로 strings.Builder에 쓰세요.