Source file
src/fmt/example_test.go
1 // Copyright 2017 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package fmt_test
6
7 import (
8 "fmt"
9 "io"
10 "math"
11 "os"
12 "strings"
13 "time"
14 )
15
16 // The Errorf function lets us use formatting features
17 // to create descriptive error messages.
18 func ExampleErrorf() {
19 const name, id = "bueller", 17
20 err := fmt.Errorf("user %q (id %d) not found", name, id)
21 fmt.Println(err.Error())
22
23 // Output: user "bueller" (id 17) not found
24 }
25
26 func ExampleFscanf() {
27 var (
28 i int
29 b bool
30 s string
31 )
32 r := strings.NewReader("5 true gophers")
33 n, err := fmt.Fscanf(r, "%d %t %s", &i, &b, &s)
34 if err != nil {
35 fmt.Fprintf(os.Stderr, "Fscanf: %v\n", err)
36 }
37 fmt.Println(i, b, s)
38 fmt.Println(n)
39 // Output:
40 // 5 true gophers
41 // 3
42 }
43
44 func ExampleFscanln() {
45 s := `dmr 1771 1.61803398875
46 ken 271828 3.14159`
47 r := strings.NewReader(s)
48 var a string
49 var b int
50 var c float64
51 for {
52 n, err := fmt.Fscanln(r, &a, &b, &c)
53 if err == io.EOF {
54 break
55 }
56 if err != nil {
57 panic(err)
58 }
59 fmt.Printf("%d: %s, %d, %f\n", n, a, b, c)
60 }
61 // Output:
62 // 3: dmr, 1771, 1.618034
63 // 3: ken, 271828, 3.141590
64 }
65
66 func ExampleSscanf() {
67 var name string
68 var age int
69 n, err := fmt.Sscanf("Kim is 22 years old", "%s is %d years old", &name, &age)
70 if err != nil {
71 panic(err)
72 }
73 fmt.Printf("%d: %s, %d\n", n, name, age)
74
75 // Output:
76 // 2: Kim, 22
77 }
78
79 func ExamplePrint() {
80 const name, age = "Kim", 22
81 fmt.Print(name, " is ", age, " years old.\n")
82
83 // It is conventional not to worry about any
84 // error returned by Print.
85
86 // Output:
87 // Kim is 22 years old.
88 }
89
90 func ExamplePrintln() {
91 const name, age = "Kim", 22
92 fmt.Println(name, "is", age, "years old.")
93
94 // It is conventional not to worry about any
95 // error returned by Println.
96
97 // Output:
98 // Kim is 22 years old.
99 }
100
101 func ExamplePrintf() {
102 const name, age = "Kim", 22
103 fmt.Printf("%s is %d years old.\n", name, age)
104
105 // It is conventional not to worry about any
106 // error returned by Printf.
107
108 // Output:
109 // Kim is 22 years old.
110 }
111
112 func ExampleSprint() {
113 const name, age = "Kim", 22
114 s := fmt.Sprint(name, " is ", age, " years old.\n")
115
116 io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
117
118 // Output:
119 // Kim is 22 years old.
120 }
121
122 func ExampleSprintln() {
123 const name, age = "Kim", 22
124 s := fmt.Sprintln(name, "is", age, "years old.")
125
126 io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
127
128 // Output:
129 // Kim is 22 years old.
130 }
131
132 func ExampleSprintf() {
133 const name, age = "Kim", 22
134 s := fmt.Sprintf("%s is %d years old.\n", name, age)
135
136 io.WriteString(os.Stdout, s) // Ignoring error for simplicity.
137
138 // Output:
139 // Kim is 22 years old.
140 }
141
142 func ExampleFprint() {
143 const name, age = "Kim", 22
144 n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")
145
146 // The n and err return values from Fprint are
147 // those returned by the underlying io.Writer.
148 if err != nil {
149 fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
150 }
151 fmt.Print(n, " bytes written.\n")
152
153 // Output:
154 // Kim is 22 years old.
155 // 21 bytes written.
156 }
157
158 func ExampleFprintln() {
159 const name, age = "Kim", 22
160 n, err := fmt.Fprintln(os.Stdout, name, "is", age, "years old.")
161
162 // The n and err return values from Fprintln are
163 // those returned by the underlying io.Writer.
164 if err != nil {
165 fmt.Fprintf(os.Stderr, "Fprintln: %v\n", err)
166 }
167 fmt.Println(n, "bytes written.")
168
169 // Output:
170 // Kim is 22 years old.
171 // 21 bytes written.
172 }
173
174 func ExampleFprintf() {
175 const name, age = "Kim", 22
176 n, err := fmt.Fprintf(os.Stdout, "%s is %d years old.\n", name, age)
177
178 // The n and err return values from Fprintf are
179 // those returned by the underlying io.Writer.
180 if err != nil {
181 fmt.Fprintf(os.Stderr, "Fprintf: %v\n", err)
182 }
183 fmt.Printf("%d bytes written.\n", n)
184
185 // Output:
186 // Kim is 22 years old.
187 // 21 bytes written.
188 }
189
190 // Print, Println, and Printf lay out their arguments differently. In this example
191 // we can compare their behaviors. Println always adds blanks between the items it
192 // prints, while Print adds blanks only between non-string arguments and Printf
193 // does exactly what it is told.
194 // Sprint, Sprintln, Sprintf, Fprint, Fprintln, and Fprintf behave the same as
195 // their corresponding Print, Println, and Printf functions shown here.
196 func Example_printers() {
197 a, b := 3.0, 4.0
198 h := math.Hypot(a, b)
199
200 // Print inserts blanks between arguments when neither is a string.
201 // It does not add a newline to the output, so we add one explicitly.
202 fmt.Print("The vector (", a, b, ") has length ", h, ".\n")
203
204 // Println always inserts spaces between its arguments,
205 // so it cannot be used to produce the same output as Print in this case;
206 // its output has extra spaces.
207 // Also, Println always adds a newline to the output.
208 fmt.Println("The vector (", a, b, ") has length", h, ".")
209
210 // Printf provides complete control but is more complex to use.
211 // It does not add a newline to the output, so we add one explicitly
212 // at the end of the format specifier string.
213 fmt.Printf("The vector (%g %g) has length %g.\n", a, b, h)
214
215 // Output:
216 // The vector (3 4) has length 5.
217 // The vector ( 3 4 ) has length 5 .
218 // The vector (3 4) has length 5.
219 }
220
221 // These examples demonstrate the basics of printing using a format string. Printf,
222 // Sprintf, and Fprintf all take a format string that specifies how to format the
223 // subsequent arguments. For example, %d (we call that a 'verb') says to print the
224 // corresponding argument, which must be an integer (or something containing an
225 // integer, such as a slice of ints) in decimal. The verb %v ('v' for 'value')
226 // always formats the argument in its default form, just how Print or Println would
227 // show it. The special verb %T ('T' for 'Type') prints the type of the argument
228 // rather than its value. The examples are not exhaustive; see the package comment
229 // for all the details.
230 func Example_formats() {
231 // A basic set of examples showing that %v is the default format, in this
232 // case decimal for integers, which can be explicitly requested with %d;
233 // the output is just what Println generates.
234 integer := 23
235 // Each of these prints "23" (without the quotes).
236 fmt.Println(integer)
237 fmt.Printf("%v\n", integer)
238 fmt.Printf("%d\n", integer)
239
240 // The special verb %T shows the type of an item rather than its value.
241 fmt.Printf("%T %T\n", integer, &integer)
242 // Result: int *int
243
244 // Println(x) is the same as Printf("%v\n", x) so we will use only Printf
245 // in the following examples. Each one demonstrates how to format values of
246 // a particular type, such as integers or strings. We start each format
247 // string with %v to show the default output and follow that with one or
248 // more custom formats.
249
250 // Booleans print as "true" or "false" with %v or %t.
251 truth := true
252 fmt.Printf("%v %t\n", truth, truth)
253 // Result: true true
254
255 // Integers print as decimals with %v and %d,
256 // or in hex with %x, octal with %o, or binary with %b.
257 answer := 42
258 fmt.Printf("%v %d %x %o %b\n", answer, answer, answer, answer, answer)
259 // Result: 42 42 2a 52 101010
260
261 // Floats have multiple formats: %v and %g print a compact representation,
262 // while %f prints a decimal point and %e uses exponential notation. The
263 // format %6.2f used here shows how to set the width and precision to
264 // control the appearance of a floating-point value. In this instance, 6 is
265 // the total width of the printed text for the value (note the extra spaces
266 // in the output) and 2 is the number of decimal places to show.
267 pi := math.Pi
268 fmt.Printf("%v %g %.2f (%6.2f) %e\n", pi, pi, pi, pi, pi)
269 // Result: 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00
270
271 // Complex numbers format as parenthesized pairs of floats, with an 'i'
272 // after the imaginary part.
273 point := 110.7 + 22.5i
274 fmt.Printf("%v %g %.2f %.2e\n", point, point, point, point)
275 // Result: (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
276
277 // Runes are integers but when printed with %c show the character with that
278 // Unicode value. The %q verb shows them as quoted characters, %U as a
279 // hex Unicode code point, and %#U as both a code point and a quoted
280 // printable form if the rune is printable.
281 smile := 'π'
282 fmt.Printf("%v %d %c %q %U %#U\n", smile, smile, smile, smile, smile, smile)
283 // Result: 128512 128512 π 'π' U+1F600 U+1F600 'π'
284
285 // Strings are formatted with %v and %s as-is, with %q as quoted strings,
286 // and %#q as backquoted strings.
287 placeholders := `foo "bar"`
288 fmt.Printf("%v %s %q %#q\n", placeholders, placeholders, placeholders, placeholders)
289 // Result: foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
290
291 // Maps formatted with %v show keys and values in their default formats.
292 // The %#v form (the # is called a "flag" in this context) shows the map in
293 // the Go source format. Maps are printed in a consistent order, sorted
294 // by the values of the keys.
295 isLegume := map[string]bool{
296 "peanut": true,
297 "dachshund": false,
298 }
299 fmt.Printf("%v %#v\n", isLegume, isLegume)
300 // Result: map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
301
302 // Structs formatted with %v show field values in their default formats.
303 // The %+v form shows the fields by name, while %#v formats the struct in
304 // Go source format.
305 person := struct {
306 Name string
307 Age int
308 }{"Kim", 22}
309 fmt.Printf("%v %+v %#v\n", person, person, person)
310 // Result: {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
311
312 // The default format for a pointer shows the underlying value preceded by
313 // an ampersand. The %p verb prints the pointer value in hex. We use a
314 // typed nil for the argument to %p here because the value of any non-nil
315 // pointer would change from run to run; run the commented-out Printf
316 // call yourself to see.
317 pointer := &person
318 fmt.Printf("%v %p\n", pointer, (*int)(nil))
319 // Result: &{Kim 22} 0x0
320 // fmt.Printf("%v %p\n", pointer, pointer)
321 // Result: &{Kim 22} 0x010203 // See comment above.
322
323 // Arrays and slices are formatted by applying the format to each element.
324 greats := [5]string{"Kitano", "Kobayashi", "Kurosawa", "Miyazaki", "Ozu"}
325 fmt.Printf("%v %q\n", greats, greats)
326 // Result: [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
327
328 kGreats := greats[:3]
329 fmt.Printf("%v %q %#v\n", kGreats, kGreats, kGreats)
330 // Result: [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
331
332 // Byte slices are special. Integer verbs like %d print the elements in
333 // that format. The %s and %q forms treat the slice like a string. The %x
334 // verb has a special form with the space flag that puts a space between
335 // the bytes.
336 cmd := []byte("aβ")
337 fmt.Printf("%v %d %s %q %x % x\n", cmd, cmd, cmd, cmd, cmd, cmd)
338 // Result: [97 226 140 152] [97 226 140 152] aβ "aβ" 61e28c98 61 e2 8c 98
339
340 // Types that implement Stringer are printed the same as strings. Because
341 // Stringers return a string, we can print them using a string-specific
342 // verb such as %q.
343 now := time.Unix(123456789, 0).UTC() // time.Time implements fmt.Stringer.
344 fmt.Printf("%v %q\n", now, now)
345 // Result: 1973εΉ΄11ζ29ζ₯ 21:33:09 +0000 UTC "1973εΉ΄11ζ29ζ₯ 21:33:09 +0000 UTC"
346
347 // Output:
348 // 23
349 // 23
350 // 23
351 // int *int
352 // true true
353 // 42 42 2a 52 101010
354 // 3.141592653589793 3.141592653589793 3.14 ( 3.14) 3.141593e+00
355 // (110.7+22.5i) (110.7+22.5i) (110.70+22.50i) (1.11e+02+2.25e+01i)
356 // 128512 128512 π 'π' U+1F600 U+1F600 'π'
357 // foo "bar" foo "bar" "foo \"bar\"" `foo "bar"`
358 // map[dachshund:false peanut:true] map[string]bool{"dachshund":false, "peanut":true}
359 // {Kim 22} {Name:Kim Age:22} struct { Name string; Age int }{Name:"Kim", Age:22}
360 // &{Kim 22} 0x0
361 // [Kitano Kobayashi Kurosawa Miyazaki Ozu] ["Kitano" "Kobayashi" "Kurosawa" "Miyazaki" "Ozu"]
362 // [Kitano Kobayashi Kurosawa] ["Kitano" "Kobayashi" "Kurosawa"] []string{"Kitano", "Kobayashi", "Kurosawa"}
363 // [97 226 140 152] [97 226 140 152] aβ "aβ" 61e28c98 61 e2 8c 98
364 // 1973εΉ΄11ζ29ζ₯ 21:33:09 +0000 UTC "1973εΉ΄11ζ29ζ₯ 21:33:09 +0000 UTC"
365 }
366
View as plain text