The fmt Package

fmt formats values for printing, building strings, and reading input. Every %-verb, and the Print/Scan functions that consume them, live here.

Examples

Printf formats according to a format specifier and writes to standard output. Use with format specifiers like %T - which prints a value's Type.

name := "Gopher"
age := 5
price := 19.99
active := true

fmt.Printf("%s is %d years old\n", name, age)
fmt.Printf("price: %.2f, active: %t\n", price, active)
fmt.Printf("%q\n", name)
fmt.Printf("%v (%T)\n", price, price)

Output

Gopher is 5 years old
price: 19.99, active: true
"Gopher"
19.99 (float64)

Sprintf runs the same formatting engine as Printf but returns a string instead of writing it, for building a value that's stored or passed on rather than printed directly.

userID := 42
key := fmt.Sprintf("user:%d:sessions", userID)
fmt.Println(key)

Output

user:42:sessions

Fprintf writes to any io.Writer: standard error, a bytes.Buffer, an open file, an HTTP response. Printf is just Fprintf(os.Stdout, ...) underneath.

var buf bytes.Buffer
count := 7
fmt.Fprintf(&buf, "%d items", count)
fmt.Println(buf.String())

fmt.Fprintf(os.Stderr, "warning: %v\n", err)

Output

7 items
warning: lookup 42: not found

%v is the default form. %+v adds field names for a struct. %#v prints Go syntax you could paste back into source.

type Point struct{ X, Y int }

p := Point{3, 4}
fmt.Printf("%v\n", p)
fmt.Printf("%+v\n", p)
fmt.Printf("%#v\n", p)

Output

{3 4}
{X:3 Y:4}
main.Point{X:3, Y:4}

A String() string method satisfies fmt.Stringer. Println and both %v and %+v call it automatically; only %#v bypasses it to show the raw Go syntax.

type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}

p := Point{3, 4}
fmt.Printf("%v\n", p)
fmt.Printf("%+v\n", p)
fmt.Printf("%#v\n", p)

Output

(3, 4)
(3, 4)
main.Point{X:3, Y:4}

A minus flag left-aligns, a plain number sets a minimum field width, and .N on a float sets decimal precision. This is the combination behind most hand-rolled column output.

rows := []struct {
    Name  string
    Price float64
}{
    {"Widget", 3.5},
    {"Gadget", 19.99},
}

for _, r := range rows {
    fmt.Printf("%-10s %6.2f\n", r.Name, r.Price)
}

Output

Widget       3.50
Gadget      19.99

%q escapes a string into a double-quoted Go literal, or a rune into a single-quoted one, safe to print without breaking on control characters.

fmt.Printf("%q\n", "hi\n")
fmt.Printf("%q\n", 'A')

Output

"hi\n"
'A'

Print functions

Function	Description
Print(a ...any) (n int, err error)	Writes operands to standard output, adding spaces between operands when neither is a string.
Behavior Adds a space between operands only where neither side is a string, so `Print`("a", "b") gives "ab" while `Print`(1, 2) gives "1 2". No trailing newline. Use when You control the spacing yourself. `Println` when you want a space between everything and a newline at the end.
Println(a ...any) (n int, err error) `Println("go", 1) // "go 1\n"`	Like Print, but always spaces operands and appends a trailing newline.
Behavior Always a space between operands, always a trailing newline. The rule that makes `Print` surprising does not apply here. Use when Almost always, for a line of output. This is the default to reach for.
Printf(format string, a ...any) (n int, err error) `Printf("%s=%d\n", "x", 1)`	Writes a format string to standard output, substituting a verb for each operand in order.
Input A format string and the operands its verbs consume. Extra operands print as `%!(EXTRA ...)`, missing ones as `%!v(MISSING)`. Output Bytes written and an `error`, both almost always ignored when writing to stdout. Behavior No trailing newline unless the format string ends in one, which is the most common cause of output running together. Every verb in a format string must have a matching operand, in order. Too few operands prints a `%!s(MISSING)`-style error inline instead of panicking; too many appends `%!(EXTRA ...)` after the formatted output. `fmt.Printf("%s is %d", "go") // go is %!d(MISSING) fmt.Printf("%s", "go", 1) // go%!(EXTRA int=1)`
Sprint(a ...any) string	Like Print, but returns the formatted result as a string instead of writing it.
Sprintln(a ...any) string	Like Println, but returns the formatted result as a string instead of writing it.
Sprintf(format string, a ...any) string `Sprintf("%02d:%02d", 9, 5) // "09:05"`	Like Printf, but returns the formatted result as a string instead of writing it.
Output A `string`. No error, because building a string cannot fail. Use when Building a message, a key, or a log line. Reach for `strings.Builder` instead when concatenating in a loop. Use `Sprintf` whenever the formatted text is going to be stored, returned, or passed somewhere else rather than printed directly, it's the same formatting engine as `Printf` without the write. `key := fmt.Sprintf("user:%d:sessions", userID) redisClient.Get(ctx, key)`
Fprint(w io.Writer, a ...any) (n int, err error)	Like Print, but writes to any io.Writer instead of standard output.
Fprintln(w io.Writer, a ...any) (n int, err error)	Like Println, but writes to any io.Writer instead of standard output.
Fprintf(w io.Writer, format string, a ...any) (n int, err error) `Fprintf(os.Stderr, "warn: %v\n", err)`	Like Printf, but writes to any io.Writer instead of standard output.
`os.Stdout` and `os.Stderr` are both `io.Writer`s, so is a `bytes.Buffer`, an open file, or an HTTP response. `Printf` is really just `Fprintf(os.Stdout, ...)` underneath. `fmt.Fprintf(os.Stderr, "warning: %v\n", err) var buf bytes.Buffer fmt.Fprintf(&buf, "%d items", count)`
Append(b []byte, a ...any) []byte	Like Print, but appends the formatted result to b instead of writing it.
Appendln(b []byte, a ...any) []byte	Like Println, but appends the formatted result to b instead of writing it.
Appendf(b []byte, format string, a ...any) []byte	Like Printf, but appends the formatted result to b instead of writing it.
Errorf(format string, a ...any) error `Errorf("open %s: %w", path, err)`	Formats like Sprintf, but returns an error. A %w verb wraps another error instead of just stringifying it.
Input A format string and its operands. A `%w` verb marks one operand as the error being wrapped. Output An `error` whose message is the formatted string. Behavior `%w` keeps the original reachable through `errors.Is` and `errors.As`. `%v` flattens it to text, which silently breaks any caller matching on the cause. Use when Adding context to an error you are passing up. Use `%w` unless you deliberately want to hide the cause. A single `%w` verb wraps the given error, keeping it inspectable through `errors.Is` and `errors.As` instead of flattening it into a plain string like every other verb does. `err := fmt.Errorf("config: %w", os.ErrNotExist) fmt.Println(errors.Is(err, os.ErrNotExist)) // true`

Scan functions

Function	Description
Scan(a ...any) (n int, err error)	Reads space-separated values from standard input into the pointers in a, newlines count as spaces.
Input Pointers to the values to fill. Passing a value rather than a pointer fails at run time, not compile time. Output The count of items successfully scanned, and an `error`. Check the count, not just the error. Behavior Treats newlines as ordinary space, so it reads across lines until everything is filled. Use when Input is whitespace-separated and line breaks carry no meaning. `Scanln` when they do. Both fill the same pointers. `Scan` treats a newline as ordinary whitespace and keeps reading until every argument is filled, so a short line pulls in the next one. `Scanln` stops at the newline and reports an error instead. `var a, b string // input: "one\ntwo\n" fmt.Scan(&a, &b) // a="one" b="two", read across two lines fmt.Scanln(&a, &b) // error: unexpected newline`
Scanln(a ...any) (n int, err error)	Like Scan, but stops at a newline and requires one to appear after the last item.
Behavior Stops at a newline. Fewer items on the line than arguments is an error rather than a prompt for more input. Use when One record per line, where a short line should fail rather than swallow the next one. Both fill the same pointers. `Scan` treats a newline as ordinary whitespace and keeps reading until every argument is filled, so a short line pulls in the next one. `Scanln` stops at the newline and reports an error instead. `var a, b string // input: "one\ntwo\n" fmt.Scan(&a, &b) // a="one" b="two", read across two lines fmt.Scanln(&a, &b) // error: unexpected newline`
Scanf(format string, a ...any) (n int, err error) `Scanf("%d-%d", &m, &d)`	Reads from standard input according to a format string, mirroring Printf's verbs.
Sscan(str string, a ...any) (n int, err error)	Like Scan, but reads from the string str instead of standard input.
Sscanln(str string, a ...any) (n int, err error)	Like Scanln, but reads from the string str instead of standard input.
Sscanf(str, format string, a ...any) (n int, err error) `Sscanf("09:05", "%d:%d", &h, &m)`	Like Scanf, but reads from the string str instead of standard input.
Fscan(r io.Reader, a ...any) (n int, err error)	Like Scan, but reads from any io.Reader instead of standard input.
Fscanln(r io.Reader, a ...any) (n int, err error)	Like Scanln, but reads from any io.Reader instead of standard input.
Fscanf(r io.Reader, format string, a ...any) (n int, err error)	Like Scanf, but reads from any io.Reader instead of standard input.

Verbs

Format Verb Notes Every verb, flag, width and precision form, with the exact output each one prints. Plus the interfaces that change it, and which verb to reach for.

Previous flag Next Topic html/template