src/strconv/example_test.go

   1 // Copyright 2015 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 strconv_test
   6
   7 import (
   8         "fmt"
   9         "log"
  10         "strconv"
  11 )
  12
  13 func ExampleAppendBool() {
  14         b := []byte("bool:")
  15         b = strconv.AppendBool(b, true)
  16         fmt.Println(string(b))
  17
  18         // Output:
  19         // bool:true
  20 }
  21
  22 func ExampleAppendFloat() {
  23         b32 := []byte("float32:")
  24         b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
  25         fmt.Println(string(b32))
  26
  27         b64 := []byte("float64:")
  28         b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
  29         fmt.Println(string(b64))
  30
  31         // Output:
  32         // float32:3.1415927E+00
  33         // float64:3.1415926535E+00
  34 }
  35
  36 func ExampleAppendInt() {
  37         b10 := []byte("int (base 10):")
  38         b10 = strconv.AppendInt(b10, -42, 10)
  39         fmt.Println(string(b10))
  40
  41         b16 := []byte("int (base 16):")
  42         b16 = strconv.AppendInt(b16, -42, 16)
  43         fmt.Println(string(b16))
  44
  45         // Output:
  46         // int (base 10):-42
  47         // int (base 16):-2a
  48 }
  49
  50 func ExampleAppendQuote() {
  51         b := []byte("quote:")
  52         b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
  53         fmt.Println(string(b))
  54
  55         // Output:
  56         // quote:"\"Fran & Freddie's Diner\""
  57 }
  58
  59 func ExampleAppendQuoteRune() {
  60         b := []byte("rune:")
  61         b = strconv.AppendQuoteRune(b, '☺')
  62         fmt.Println(string(b))
  63
  64         // Output:
  65         // rune:'☺'
  66 }
  67
  68 func ExampleAppendQuoteRuneToASCII() {
  69         b := []byte("rune (ascii):")
  70         b = strconv.AppendQuoteRuneToASCII(b, '☺')
  71         fmt.Println(string(b))
  72
  73         // Output:
  74         // rune (ascii):'\u263a'
  75 }
  76
  77 func ExampleAppendQuoteToASCII() {
  78         b := []byte("quote (ascii):")
  79         b = strconv.AppendQuoteToASCII(b, `"Fran & Freddie's Diner"`)
  80         fmt.Println(string(b))
  81
  82         // Output:
  83         // quote (ascii):"\"Fran & Freddie's Diner\""
  84 }
  85
  86 func ExampleAppendUint() {
  87         b10 := []byte("uint (base 10):")
  88         b10 = strconv.AppendUint(b10, 42, 10)
  89         fmt.Println(string(b10))
  90
  91         b16 := []byte("uint (base 16):")
  92         b16 = strconv.AppendUint(b16, 42, 16)
  93         fmt.Println(string(b16))
  94
  95         // Output:
  96         // uint (base 10):42
  97         // uint (base 16):2a
  98 }
  99
 100 func ExampleAtoi() {
 101         v := "10"
 102         if s, err := strconv.Atoi(v); err == nil {
 103                 fmt.Printf("%T, %v", s, s)
 104         }
 105
 106         // Output:
 107         // int, 10
 108 }
 109
 110 func ExampleCanBackquote() {
 111         fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
 112         fmt.Println(strconv.CanBackquote("`can't backquote this`"))
 113
 114         // Output:
 115         // true
 116         // false
 117 }
 118
 119 func ExampleFormatBool() {
 120         v := true
 121         s := strconv.FormatBool(v)
 122         fmt.Printf("%T, %v\n", s, s)
 123
 124         // Output:
 125         // string, true
 126 }
 127
 128 func ExampleFormatFloat() {
 129         v := 3.1415926535
 130
 131         s32 := strconv.FormatFloat(v, 'E', -1, 32)
 132         fmt.Printf("%T, %v\n", s32, s32)
 133
 134         s64 := strconv.FormatFloat(v, 'E', -1, 64)
 135         fmt.Printf("%T, %v\n", s64, s64)
 136
 137         // fmt.Println uses these arguments to print floats
 138         fmt64 := strconv.FormatFloat(v, 'g', -1, 64)
 139         fmt.Printf("%T, %v\n", fmt64, fmt64)
 140
 141         // Output:
 142         // string, 3.1415927E+00
 143         // string, 3.1415926535E+00
 144         // string, 3.1415926535
 145 }
 146
 147 func ExampleFormatInt() {
 148         v := int64(-42)
 149
 150         s10 := strconv.FormatInt(v, 10)
 151         fmt.Printf("%T, %v\n", s10, s10)
 152
 153         s16 := strconv.FormatInt(v, 16)
 154         fmt.Printf("%T, %v\n", s16, s16)
 155
 156         // Output:
 157         // string, -42
 158         // string, -2a
 159 }
 160
 161 func ExampleFormatUint() {
 162         v := uint64(42)
 163
 164         s10 := strconv.FormatUint(v, 10)
 165         fmt.Printf("%T, %v\n", s10, s10)
 166
 167         s16 := strconv.FormatUint(v, 16)
 168         fmt.Printf("%T, %v\n", s16, s16)
 169
 170         // Output:
 171         // string, 42
 172         // string, 2a
 173 }
 174
 175 func ExampleIsGraphic() {
 176         shamrock := strconv.IsGraphic('☘')
 177         fmt.Println(shamrock)
 178
 179         a := strconv.IsGraphic('a')
 180         fmt.Println(a)
 181
 182         bel := strconv.IsGraphic('\007')
 183         fmt.Println(bel)
 184
 185         // Output:
 186         // true
 187         // true
 188         // false
 189 }
 190
 191 func ExampleIsPrint() {
 192         c := strconv.IsPrint('\u263a')
 193         fmt.Println(c)
 194
 195         bel := strconv.IsPrint('\007')
 196         fmt.Println(bel)
 197
 198         // Output:
 199         // true
 200         // false
 201 }
 202
 203 func ExampleItoa() {
 204         i := 10
 205         s := strconv.Itoa(i)
 206         fmt.Printf("%T, %v\n", s, s)
 207
 208         // Output:
 209         // string, 10
 210 }
 211
 212 func ExampleParseBool() {
 213         v := "true"
 214         if s, err := strconv.ParseBool(v); err == nil {
 215                 fmt.Printf("%T, %v\n", s, s)
 216         }
 217
 218         // Output:
 219         // bool, true
 220 }
 221
 222 func ExampleParseFloat() {
 223         v := "3.1415926535"
 224         if s, err := strconv.ParseFloat(v, 32); err == nil {
 225                 fmt.Printf("%T, %v\n", s, s)
 226         }
 227         if s, err := strconv.ParseFloat(v, 64); err == nil {
 228                 fmt.Printf("%T, %v\n", s, s)
 229         }
 230         if s, err := strconv.ParseFloat("NaN", 32); err == nil {
 231                 fmt.Printf("%T, %v\n", s, s)
 232         }
 233         // ParseFloat is case insensitive
 234         if s, err := strconv.ParseFloat("nan", 32); err == nil {
 235                 fmt.Printf("%T, %v\n", s, s)
 236         }
 237         if s, err := strconv.ParseFloat("inf", 32); err == nil {
 238                 fmt.Printf("%T, %v\n", s, s)
 239         }
 240         if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
 241                 fmt.Printf("%T, %v\n", s, s)
 242         }
 243         if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
 244                 fmt.Printf("%T, %v\n", s, s)
 245         }
 246         if s, err := strconv.ParseFloat("-0", 32); err == nil {
 247                 fmt.Printf("%T, %v\n", s, s)
 248         }
 249         if s, err := strconv.ParseFloat("+0", 32); err == nil {
 250                 fmt.Printf("%T, %v\n", s, s)
 251         }
 252
 253         // Output:
 254         // float64, 3.1415927410125732
 255         // float64, 3.1415926535
 256         // float64, NaN
 257         // float64, NaN
 258         // float64, +Inf
 259         // float64, +Inf
 260         // float64, -Inf
 261         // float64, -0
 262         // float64, 0
 263 }
 264
 265 func ExampleParseInt() {
 266         v32 := "-354634382"
 267         if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
 268                 fmt.Printf("%T, %v\n", s, s)
 269         }
 270         if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
 271                 fmt.Printf("%T, %v\n", s, s)
 272         }
 273
 274         v64 := "-3546343826724305832"
 275         if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
 276                 fmt.Printf("%T, %v\n", s, s)
 277         }
 278         if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
 279                 fmt.Printf("%T, %v\n", s, s)
 280         }
 281
 282         // Output:
 283         // int64, -354634382
 284         // int64, -3546343826724305832
 285 }
 286
 287 func ExampleParseUint() {
 288         v := "42"
 289         if s, err := strconv.ParseUint(v, 10, 32); err == nil {
 290                 fmt.Printf("%T, %v\n", s, s)
 291         }
 292         if s, err := strconv.ParseUint(v, 10, 64); err == nil {
 293                 fmt.Printf("%T, %v\n", s, s)
 294         }
 295
 296         // Output:
 297         // uint64, 42
 298         // uint64, 42
 299 }
 300
 301 func ExampleQuote() {
 302         // This string literal contains a tab character.
 303         s := strconv.Quote(`"Fran & Freddie's Diner     ☺"`)
 304         fmt.Println(s)
 305
 306         // Output:
 307         // "\"Fran & Freddie's Diner\t☺\""
 308 }
 309
 310 func ExampleQuoteRune() {
 311         s := strconv.QuoteRune('☺')
 312         fmt.Println(s)
 313
 314         // Output:
 315         // '☺'
 316 }
 317
 318 func ExampleQuoteRuneToASCII() {
 319         s := strconv.QuoteRuneToASCII('☺')
 320         fmt.Println(s)
 321
 322         // Output:
 323         // '\u263a'
 324 }
 325
 326 func ExampleQuoteRuneToGraphic() {
 327         s := strconv.QuoteRuneToGraphic('☺')
 328         fmt.Println(s)
 329
 330         s = strconv.QuoteRuneToGraphic('\u263a')
 331         fmt.Println(s)
 332
 333         s = strconv.QuoteRuneToGraphic('\u000a')
 334         fmt.Println(s)
 335
 336         s = strconv.QuoteRuneToGraphic('        ') // tab character
 337         fmt.Println(s)
 338
 339         // Output:
 340         // '☺'
 341         // '☺'
 342         // '\n'
 343         // '\t'
 344 }
 345
 346 func ExampleQuoteToASCII() {
 347         // This string literal contains a tab character.
 348         s := strconv.QuoteToASCII(`"Fran & Freddie's Diner      ☺"`)
 349         fmt.Println(s)
 350
 351         // Output:
 352         // "\"Fran & Freddie's Diner\t\u263a\""
 353 }
 354
 355 func ExampleQuoteToGraphic() {
 356         s := strconv.QuoteToGraphic("☺")
 357         fmt.Println(s)
 358
 359         // This string literal contains a tab character.
 360         s = strconv.QuoteToGraphic("This is a \u263a    \u000a")
 361         fmt.Println(s)
 362
 363         s = strconv.QuoteToGraphic(`" This is a ☺ \n "`)
 364         fmt.Println(s)
 365
 366         // Output:
 367         // "☺"
 368         // "This is a ☺\t\n"
 369         // "\" This is a ☺ \\n \""
 370 }
 371
 372 func ExampleQuotedPrefix() {
 373         s, err := strconv.QuotedPrefix("not a quoted string")
 374         fmt.Printf("%q, %v\n", s, err)
 375         s, err = strconv.QuotedPrefix("\"double-quoted string\" with trailing text")
 376         fmt.Printf("%q, %v\n", s, err)
 377         s, err = strconv.QuotedPrefix("`or backquoted` with more trailing text")
 378         fmt.Printf("%q, %v\n", s, err)
 379         s, err = strconv.QuotedPrefix("'\u263a' is also okay")
 380         fmt.Printf("%q, %v\n", s, err)
 381
 382         // Output:
 383         // "", invalid syntax
 384         // "\"double-quoted string\"", <nil>
 385         // "`or backquoted`", <nil>
 386         // "'☺'", <nil>
 387 }
 388
 389 func ExampleUnquote() {
 390         s, err := strconv.Unquote("You can't unquote a string without quotes")
 391         fmt.Printf("%q, %v\n", s, err)
 392         s, err = strconv.Unquote("\"The string must be either double-quoted\"")
 393         fmt.Printf("%q, %v\n", s, err)
 394         s, err = strconv.Unquote("`or backquoted.`")
 395         fmt.Printf("%q, %v\n", s, err)
 396         s, err = strconv.Unquote("'\u263a'") // single character only allowed in single quotes
 397         fmt.Printf("%q, %v\n", s, err)
 398         s, err = strconv.Unquote("'\u2639\u2639'")
 399         fmt.Printf("%q, %v\n", s, err)
 400
 401         // Output:
 402         // "", invalid syntax
 403         // "The string must be either double-quoted", <nil>
 404         // "or backquoted.", <nil>
 405         // "☺", <nil>
 406         // "", invalid syntax
 407 }
 408
 409 func ExampleUnquoteChar() {
 410         v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
 411         if err != nil {
 412                 log.Fatal(err)
 413         }
 414
 415         fmt.Println("value:", string(v))
 416         fmt.Println("multibyte:", mb)
 417         fmt.Println("tail:", t)
 418
 419         // Output:
 420         // value: "
 421         // multibyte: false
 422         // tail: Fran & Freddie's Diner\"
 423 }
 424
 425 func ExampleNumError() {
 426         str := "Not a number"
 427         if _, err := strconv.ParseFloat(str, 64); err != nil {
 428                 e := err.(*strconv.NumError)
 429                 fmt.Println("Func:", e.Func)
 430                 fmt.Println("Num:", e.Num)
 431                 fmt.Println("Err:", e.Err)
 432                 fmt.Println(err)
 433         }
 434
 435         // Output:
 436         // Func: ParseFloat
 437         // Num: Not a number
 438         // Err: invalid syntax
 439         // strconv.ParseFloat: parsing "Not a number": invalid syntax
 440 }