src/fmt/example_test.go - go - Git at Google

 // Copyright 2017 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package fmt_test

 import (
 	"fmt"
 	"io"
 	"math"
 	"os"
 	"strings"
 	"time"
 )

 // The Errorf function lets us use formatting features
 // to create descriptive error messages.
 func ExampleErrorf() {
 	const name, id = "bueller", 17
 	err := fmt.Errorf("user %q (id %d) not found", name, id)
 	fmt.Println(err.Error())

 	// Output: user "bueller" (id 17) not found
 }

 func ExampleFscanf() {
 	var (
 		i int
 		b bool
 		s string
 	)
 	r := strings.NewReader("5 true gophers")
 	n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
 	}
 	fmt.Println(i, b, s)
 	fmt.Println(n)
 	// Output:
 	// 5 true gophers
 	// 3
 }

 func ExampleFscanln() {
 	s := `dmr 1771 1.61803398875
 	ken 271828 3.14159`
 	r := strings.NewReader(s)
 	var a string
 	var b int
 	var c float64
 	for {
 		n, err := fmt.Fscanln(r, &a, &b, &c)
 		if err == io.EOF {
 			break
 		}
 		if err != nil {
 			panic(err)
 		}
 		fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
 	}
 	// Output:
 	// 3: dmr, 1771, 1.618034
 	// 3: ken, 271828, 3.141590
 }

 func ExampleSscanf() {
 	var name string
 	var age int
 	n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
 	if err != nil {
 		panic(err)
 	}
 	fmt.Printf("%d: %s, %d\n", n, name, age)

 	// Output:
 	// 2: Kim, 22
 }

 func ExamplePrint() {
 	const name, age = "Kim", 22
 	fmt.Print(name, " is ", age, " years old.\n")

 	// It is conventional not to worry about any
 	// error returned by Print.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExamplePrintln() {
 	const name, age = "Kim", 22
 	fmt.Println(name, "is", age, "years old.")

 	// It is conventional not to worry about any
 	// error returned by Println.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExamplePrintf() {
 	const name, age = "Kim", 22
 	fmt.Printf("%s is %d years old.\n", name, age)

 	// It is conventional not to worry about any
 	// error returned by Printf.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExampleSprint() {
 	const name, age = "Kim", 22
 	s := fmt.Sprint(name, " is ", age, " years old.\n")

 	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExampleSprintln() {
 	const name, age = "Kim", 22
 	s := fmt.Sprintln(name, "is", age, "years old.")

 	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExampleSprintf() {
 	const name, age = "Kim", 22
 	s := fmt.Sprintf("%s is %d years old.\n", name, age)

 	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

 	// Output:
 	// Kim is 22 years old.
 }

 func ExampleFprint() {
 	const name, age = "Kim", 22
 	n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")

 	// The n and err return values from Fprint are
 	// those returned by the underlying io.Writer.
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
 	}
 	fmt.Print(n, " bytes written.\n")

 	// Output:
 	// Kim is 22 years old.
 	// 21 bytes written.
 }

 func ExampleFprintln() {
 	const name, age = "Kim", 22
 	n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")

 	// The n and err return values from Fprintln are
 	// those returned by the underlying io.Writer.
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
 	}
 	fmt.Println(n, "bytes written.")

 	// Output:
 	// Kim is 22 years old.
 	// 21 bytes written.
 }

 func ExampleFprintf() {
 	const name, age = "Kim", 22
 	n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)

 	// The n and err return values from Fprintf are
 	// those returned by the underlying io.Writer.
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
 	}
 	fmt.Printf("%d bytes written.\n", n)

 	// Output:
 	// Kim is 22 years old.
 	// 21 bytes written.
 }

 // Print, Println, and Printf lay out their arguments differently. In this example
 // we can compare their behaviors. Println always adds blanks between the items it
 // prints, while Print adds blanks only between non-string arguments and Printf
 // does exactly what it is told.
 // Sprint, Sprintln, Sprintf, Fprint, Fprintln, and Fprintf behave the same as
 // their corresponding Print, Println, and Printf functions shown here.
 func Example_printers() {
 	a, b := 3.0, 4.0
 	h := math.Hypot(a, b)

 	// Print inserts blanks between arguments when neither is a string.
 	// It does not add a newline to the output, so we add one explicitly.
 	fmt.Print("The vector (", a, b, ") has length ", h, ".\n")

 	// Println always inserts spaces between its arguments,
 	// so it cannot be used to produce the same output as Print in this case;
 	// its output has extra spaces.
 	// Also, Println always adds a newline to the output.
 	fmt.Println("The vector (", a, b, ") has length", h, ".")

 	// Printf provides complete control but is more complex to use.
 	// It does not add a newline to the output, so we add one explicitly
 	// at the end of the format specifier string.
 	fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)

 	// Output:
 	// The vector (3 4) has length 5.
 	// The vector ( 3 4 ) has length 5 .
 	// The vector (3 4) has length 5.
 }

 // These examples demonstrate the basics of printing using a format string. Printf,
 // Sprintf, and Fprintf all take a format string that specifies how to format the
 // subsequent arguments. For example, %d (we call that a 'verb') says to print the
 // corresponding argument, which must be an integer (or something containing an
 // integer, such as a slice of ints) in decimal. The verb %v ('v' for 'value')
 // always formats the argument in its default form, just how Print or Println would
 // show it. The special verb %T ('T' for 'Type') prints the type of the argument
 // rather than its value. The examples are not exhaustive; see the package comment
 // for all the details.
 func Example_formats() {
 	// A basic set of examples showing that %v is the default format, in this
 	// case decimal for integers, which can be explicitly requested with %d;
 	// the output is just what Println generates.
 	integer := 23
 	// Each of these prints "23" (without the quotes).
 	fmt.Println(integer)
 	fmt.Printf("%v\n", integer)
 	fmt.Printf("%d\n", integer)

 	// The special verb %T shows the type of an item rather than its value.
 	fmt.Printf("%T %T\n", integer, &integer)
 	// Result: int *int

 	// Println(x) is the same as Printf("%v\n", x) so we will use only Printf
 	// in the following examples. Each one demonstrates how to format values of
 	// a particular type, such as integers or strings. We start each format
 	// string with %v to show the default output and follow that with one or
 	// more custom formats.

 	// Booleans print as "true" or "false" with %v or %t.
 	truth := true
 	fmt.Printf("%v %t\n", truth, truth)
 	// Result: true true

 	// Integers print as decimals with %v and %d,
 	// or in hex with %x, octal with %o, or binary with %b.
 	answer := 42
 	fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
 	// Result: 42 42 2a 52 101010

 	// Floats have multiple formats: %v and %g print a compact representation,
 	// while %f prints a decimal point and %e uses exponential notation. The
 	// format %6.2f used here shows how to set the width and precision to
 	// control the appearance of a floating-point value. In this instance, 6 is
 	// the total width of the printed text for the value (note the extra spaces
 	// in the output) and 2 is the number of decimal places to show.
 	pi := math.Pi
 	fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
 	// Result: 3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00

 	// Complex numbers format as parenthesized pairs of floats, with an 'i'
 	// after the imaginary part.
 	point := 110.7 + 22.5i
 	fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
 	// Result: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)

 	// Runes are integers but when printed with %c show the character with that
 	// Unicode value. The %q verb shows them as quoted characters, %U as a
 	// hex Unicode code point, and %#U as both a code point and a quoted
 	// printable form if the rune is printable.
 	smile := '😀'
 	fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
 	// Result: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'

 	// Strings are formatted with %v and %s as-is, with %q as quoted strings,
 	// and %#q as backquoted strings.
 	placeholders := `foo "bar"`
 	fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
 	// Result: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`

 	// Maps formatted with %v show keys and values in their default formats.
 	// The %#v form (the # is called a "flag" in this context) shows the map in
 	// the Go source format. Maps are printed in a consistent order, sorted
 	// by the values of the keys.
 	isLegume := map[string]bool{
 		"peanut":    true,
 		"dachshund": false,
 	}
 	fmt.Printf("%v %#v\n", isLegume, isLegume)
 	// Result: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}

 	// Structs formatted with %v show field values in their default formats.
 	// The %+v form shows the fields by name, while %#v formats the struct in
 	// Go source format.
 	person := struct {
 		Name string
 		Age  int
 	}{"Kim", 22}
 	fmt.Printf("%v %+v %#v\n", person, person, person)
 	// Result: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}

 	// The default format for a pointer shows the underlying value preceded by
 	// an ampersand. The %p verb prints the pointer value in hex. We use a
 	// typed nil for the argument to %p here because the value of any non-nil
 	// pointer would change from run to run; run the commented-out Printf
 	// call yourself to see.
 	pointer := &person
 	fmt.Printf("%v %p\n", pointer, (*int)(nil))
 	// Result: &{Kim 22} 0x0
 	// fmt.Printf("%v %p\n", pointer, pointer)
 	// Result: &{Kim 22} 0x010203 // See comment above.

 	// Arrays and slices are formatted by applying the format to each element.
 	greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
 	fmt.Printf("%v %q\n", greats, greats)
 	// Result: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]

 	kGreats := greats[:3]
 	fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
 	// Result: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}

 	// Byte slices are special. Integer verbs like %d print the elements in
 	// that format. The %s and %q forms treat the slice like a string. The %x
 	// verb has a special form with the space flag that puts a space between
 	// the bytes.
 	cmd := []byte("a⌘")
 	fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
 	// Result: [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98

 	// Types that implement Stringer are printed the same as strings. Because
 	// Stringers return a string, we can print them using a string-specific
 	// verb such as %q.
 	now := time.Unix(123456789, 0).UTC() // time.Time implements fmt.Stringer.
 	fmt.Printf("%v %q\n", now, now)
 	// Result: 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

 	// Output:
 	// 23
 	// 23
 	// 23
 	// int *int
 	// true true
 	// 42 42 2a 52 101010
 	// 3.141592653589793 3.141592653589793 3.14 (  3.14) 3.141593e+00
 	// (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
 	// 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
 	// foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
 	// map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
 	// {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
 	// &{Kim 22} 0x0
 	// [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
 	// [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
 	// [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
 	// 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"
 }
	// Copyright 2017 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package fmt_test

	import (
	"fmt"
	"io"
	"math"
	"os"
	"strings"
	"time"
	)

	// The Errorf function lets us use formatting features
	// to create descriptive error messages.
	func ExampleErrorf() {
	const name, id = "bueller", 17
	err := fmt.Errorf("user %q (id %d) not found", name, id)
	fmt.Println(err.Error())

	// Output: user "bueller" (id 17) not found
	}

	func ExampleFscanf() {
	var (
	i int
	b bool
	s string
	)
	r := strings.NewReader("5 true gophers")
	n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
	if err != nil {
	fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
	}
	fmt.Println(i, b, s)
	fmt.Println(n)
	// Output:
	// 5 true gophers
	// 3
	}

	func ExampleFscanln() {
	s := `dmr 1771 1.61803398875
	ken 271828 3.14159`
	r := strings.NewReader(s)
	var a string
	var b int
	var c float64
	for {
	n, err := fmt.Fscanln(r, &a, &b, &c)
	if err == io.EOF {
	break
	}
	if err != nil {
	panic(err)
	}
	fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
	}
	// Output:
	// 3: dmr, 1771, 1.618034
	// 3: ken, 271828, 3.141590
	}

	func ExampleSscanf() {
	var name string
	var age int
	n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
	if err != nil {
	panic(err)
	}
	fmt.Printf("%d: %s, %d\n", n, name, age)

	// Output:
	// 2: Kim, 22
	}

	func ExamplePrint() {
	const name, age = "Kim", 22
	fmt.Print(name, " is ", age, " years old.\n")

	// It is conventional not to worry about any
	// error returned by Print.

	// Output:
	// Kim is 22 years old.
	}

	func ExamplePrintln() {
	const name, age = "Kim", 22
	fmt.Println(name, "is", age, "years old.")

	// It is conventional not to worry about any
	// error returned by Println.

	// Output:
	// Kim is 22 years old.
	}

	func ExamplePrintf() {
	const name, age = "Kim", 22
	fmt.Printf("%s is %d years old.\n", name, age)

	// It is conventional not to worry about any
	// error returned by Printf.

	// Output:
	// Kim is 22 years old.
	}

	func ExampleSprint() {
	const name, age = "Kim", 22
	s := fmt.Sprint(name, " is ", age, " years old.\n")

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

	// Output:
	// Kim is 22 years old.
	}

	func ExampleSprintln() {
	const name, age = "Kim", 22
	s := fmt.Sprintln(name, "is", age, "years old.")

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

	// Output:
	// Kim is 22 years old.
	}

	func ExampleSprintf() {
	const name, age = "Kim", 22
	s := fmt.Sprintf("%s is %d years old.\n", name, age)

	io.WriteString(os.Stdout, s) // Ignoring error for simplicity.

	// Output:
	// Kim is 22 years old.
	}

	func ExampleFprint() {
	const name, age = "Kim", 22
	n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")

	// The n and err return values from Fprint are
	// those returned by the underlying io.Writer.
	if err != nil {
	fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
	}
	fmt.Print(n, " bytes written.\n")

	// Output:
	// Kim is 22 years old.
	// 21 bytes written.
	}

	func ExampleFprintln() {
	const name, age = "Kim", 22
	n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")

	// The n and err return values from Fprintln are
	// those returned by the underlying io.Writer.
	if err != nil {
	fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
	}
	fmt.Println(n, "bytes written.")

	// Output:
	// Kim is 22 years old.
	// 21 bytes written.
	}

	func ExampleFprintf() {
	const name, age = "Kim", 22
	n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)

	// The n and err return values from Fprintf are
	// those returned by the underlying io.Writer.
	if err != nil {
	fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
	}
	fmt.Printf("%d bytes written.\n", n)

	// Output:
	// Kim is 22 years old.
	// 21 bytes written.
	}

	// Print, Println, and Printf lay out their arguments differently. In this example
	// we can compare their behaviors. Println always adds blanks between the items it
	// prints, while Print adds blanks only between non-string arguments and Printf
	// does exactly what it is told.
	// Sprint, Sprintln, Sprintf, Fprint, Fprintln, and Fprintf behave the same as
	// their corresponding Print, Println, and Printf functions shown here.
	func Example_printers() {
	a, b := 3.0, 4.0
	h := math.Hypot(a, b)

	// Print inserts blanks between arguments when neither is a string.
	// It does not add a newline to the output, so we add one explicitly.
	fmt.Print("The vector (", a, b, ") has length ", h, ".\n")

	// Println always inserts spaces between its arguments,
	// so it cannot be used to produce the same output as Print in this case;
	// its output has extra spaces.
	// Also, Println always adds a newline to the output.
	fmt.Println("The vector (", a, b, ") has length", h, ".")

	// Printf provides complete control but is more complex to use.
	// It does not add a newline to the output, so we add one explicitly
	// at the end of the format specifier string.
	fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)

	// Output:
	// The vector (3 4) has length 5.
	// The vector ( 3 4 ) has length 5 .
	// The vector (3 4) has length 5.
	}

	// These examples demonstrate the basics of printing using a format string. Printf,
	// Sprintf, and Fprintf all take a format string that specifies how to format the
	// subsequent arguments. For example, %d (we call that a 'verb') says to print the
	// corresponding argument, which must be an integer (or something containing an
	// integer, such as a slice of ints) in decimal. The verb %v ('v' for 'value')
	// always formats the argument in its default form, just how Print or Println would
	// show it. The special verb %T ('T' for 'Type') prints the type of the argument
	// rather than its value. The examples are not exhaustive; see the package comment
	// for all the details.
	func Example_formats() {
	// A basic set of examples showing that %v is the default format, in this
	// case decimal for integers, which can be explicitly requested with %d;
	// the output is just what Println generates.
	integer := 23
	// Each of these prints "23" (without the quotes).
	fmt.Println(integer)
	fmt.Printf("%v\n", integer)
	fmt.Printf("%d\n", integer)

	// The special verb %T shows the type of an item rather than its value.
	fmt.Printf("%T %T\n", integer, &integer)
	// Result: int *int

	// Println(x) is the same as Printf("%v\n", x) so we will use only Printf
	// in the following examples. Each one demonstrates how to format values of
	// a particular type, such as integers or strings. We start each format
	// string with %v to show the default output and follow that with one or
	// more custom formats.

	// Booleans print as "true" or "false" with %v or %t.
	truth := true
	fmt.Printf("%v %t\n", truth, truth)
	// Result: true true

	// Integers print as decimals with %v and %d,
	// or in hex with %x, octal with %o, or binary with %b.
	answer := 42
	fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
	// Result: 42 42 2a 52 101010

	// Floats have multiple formats: %v and %g print a compact representation,
	// while %f prints a decimal point and %e uses exponential notation. The
	// format %6.2f used here shows how to set the width and precision to
	// control the appearance of a floating-point value. In this instance, 6 is
	// the total width of the printed text for the value (note the extra spaces
	// in the output) and 2 is the number of decimal places to show.
	pi := math.Pi
	fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
	// Result: 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00

	// Complex numbers format as parenthesized pairs of floats, with an 'i'
	// after the imaginary part.
	point := 110.7 + 22.5i
	fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
	// Result: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)

	// Runes are integers but when printed with %c show the character with that
	// Unicode value. The %q verb shows them as quoted characters, %U as a
	// hex Unicode code point, and %#U as both a code point and a quoted
	// printable form if the rune is printable.
	smile := '😀'
	fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
	// Result: 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'

	// Strings are formatted with %v and %s as-is, with %q as quoted strings,
	// and %#q as backquoted strings.
	placeholders := `foo "bar"`
	fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
	// Result: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`

	// Maps formatted with %v show keys and values in their default formats.
	// The %#v form (the # is called a "flag" in this context) shows the map in
	// the Go source format. Maps are printed in a consistent order, sorted
	// by the values of the keys.
	isLegume := map[string]bool{
	"peanut": true,
	"dachshund": false,
	}
	fmt.Printf("%v %#v\n", isLegume, isLegume)
	// Result: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}

	// Structs formatted with %v show field values in their default formats.
	// The %+v form shows the fields by name, while %#v formats the struct in
	// Go source format.
	person := struct {
	Name string
	Age int
	}{"Kim", 22}
	fmt.Printf("%v %+v %#v\n", person, person, person)
	// Result: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}

	// The default format for a pointer shows the underlying value preceded by
	// an ampersand. The %p verb prints the pointer value in hex. We use a
	// typed nil for the argument to %p here because the value of any non-nil
	// pointer would change from run to run; run the commented-out Printf
	// call yourself to see.
	pointer := &person
	fmt.Printf("%v %p\n", pointer, (*int)(nil))
	// Result: &{Kim 22} 0x0
	// fmt.Printf("%v %p\n", pointer, pointer)
	// Result: &{Kim 22} 0x010203 // See comment above.

	// Arrays and slices are formatted by applying the format to each element.
	greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
	fmt.Printf("%v %q\n", greats, greats)
	// Result: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]

	kGreats := greats[:3]
	fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
	// Result: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}

	// Byte slices are special. Integer verbs like %d print the elements in
	// that format. The %s and %q forms treat the slice like a string. The %x
	// verb has a special form with the space flag that puts a space between
	// the bytes.
	cmd := []byte("a⌘")
	fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
	// Result: [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98

	// Types that implement Stringer are printed the same as strings. Because
	// Stringers return a string, we can print them using a string-specific
	// verb such as %q.
	now := time.Unix(123456789, 0).UTC() // time.Time implements fmt.Stringer.
	fmt.Printf("%v %q\n", now, now)
	// Result: 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"

	// Output:
	// 23
	// 23
	// 23
	// int *int
	// true true
	// 42 42 2a 52 101010
	// 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00
	// (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
	// 128512 128512 😀 '😀' U+1F600 U+1F600 '😀'
	// foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
	// map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
	// {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
	// &{Kim 22} 0x0
	// [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
	// [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
	// [97 226 140 152] [97 226 140 152] a⌘ "a⌘" 61e28c98 61 e2 8c 98
	// 1973-11-29 21:33:09 +0000 UTC "1973-11-29 21:33:09 +0000 UTC"
	}