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