libgo/go/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         // Output:
 138         // string, 3.1415927E+00
 139         // string, 3.1415926535E+00
 140 }
 141
 142 func ExampleFormatInt() {
 143         v := int64(-42)
 144
 145         s10 := strconv.FormatInt(v, 10)
 146         fmt.Printf("%T, %v\n", s10, s10)
 147
 148         s16 := strconv.FormatInt(v, 16)
 149         fmt.Printf("%T, %v\n", s16, s16)
 150
 151         // Output:
 152         // string, -42
 153         // string, -2a
 154 }
 155
 156 func ExampleFormatUint() {
 157         v := uint64(42)
 158
 159         s10 := strconv.FormatUint(v, 10)
 160         fmt.Printf("%T, %v\n", s10, s10)
 161
 162         s16 := strconv.FormatUint(v, 16)
 163         fmt.Printf("%T, %v\n", s16, s16)
 164
 165         // Output:
 166         // string, 42
 167         // string, 2a
 168 }
 169
 170 func ExampleIsGraphic() {
 171         shamrock := strconv.IsGraphic('☘')
 172         fmt.Println(shamrock)
 173
 174         a := strconv.IsGraphic('a')
 175         fmt.Println(a)
 176
 177         bel := strconv.IsGraphic('\007')
 178         fmt.Println(bel)
 179
 180         // Output:
 181         // true
 182         // true
 183         // false
 184 }
 185
 186 func ExampleIsPrint() {
 187         c := strconv.IsPrint('\u263a')
 188         fmt.Println(c)
 189
 190         bel := strconv.IsPrint('\007')
 191         fmt.Println(bel)
 192
 193         // Output:
 194         // true
 195         // false
 196 }
 197
 198 func ExampleItoa() {
 199         i := 10
 200         s := strconv.Itoa(i)
 201         fmt.Printf("%T, %v\n", s, s)
 202
 203         // Output:
 204         // string, 10
 205 }
 206
 207 func ExampleParseBool() {
 208         v := "true"
 209         if s, err := strconv.ParseBool(v); err == nil {
 210                 fmt.Printf("%T, %v\n", s, s)
 211         }
 212
 213         // Output:
 214         // bool, true
 215 }
 216
 217 func ExampleParseFloat() {
 218         v := "3.1415926535"
 219         if s, err := strconv.ParseFloat(v, 32); err == nil {
 220                 fmt.Printf("%T, %v\n", s, s)
 221         }
 222         if s, err := strconv.ParseFloat(v, 64); err == nil {
 223                 fmt.Printf("%T, %v\n", s, s)
 224         }
 225         if s, err := strconv.ParseFloat("NaN", 32); err == nil {
 226                 fmt.Printf("%T, %v\n", s, s)
 227         }
 228         // ParseFloat is case insensitive
 229         if s, err := strconv.ParseFloat("nan", 32); err == nil {
 230                 fmt.Printf("%T, %v\n", s, s)
 231         }
 232         if s, err := strconv.ParseFloat("inf", 32); err == nil {
 233                 fmt.Printf("%T, %v\n", s, s)
 234         }
 235         if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
 236                 fmt.Printf("%T, %v\n", s, s)
 237         }
 238         if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
 239                 fmt.Printf("%T, %v\n", s, s)
 240         }
 241         if s, err := strconv.ParseFloat("-0", 32); err == nil {
 242                 fmt.Printf("%T, %v\n", s, s)
 243         }
 244         if s, err := strconv.ParseFloat("+0", 32); err == nil {
 245                 fmt.Printf("%T, %v\n", s, s)
 246         }
 247
 248         // Output:
 249         // float64, 3.1415927410125732
 250         // float64, 3.1415926535
 251         // float64, NaN
 252         // float64, NaN
 253         // float64, +Inf
 254         // float64, +Inf
 255         // float64, -Inf
 256         // float64, -0
 257         // float64, 0
 258 }
 259
 260 func ExampleParseInt() {
 261         v32 := "-354634382"
 262         if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
 263                 fmt.Printf("%T, %v\n", s, s)
 264         }
 265         if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
 266                 fmt.Printf("%T, %v\n", s, s)
 267         }
 268
 269         v64 := "-3546343826724305832"
 270         if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
 271                 fmt.Printf("%T, %v\n", s, s)
 272         }
 273         if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
 274                 fmt.Printf("%T, %v\n", s, s)
 275         }
 276
 277         // Output:
 278         // int64, -354634382
 279         // int64, -3546343826724305832
 280 }
 281
 282 func ExampleParseUint() {
 283         v := "42"
 284         if s, err := strconv.ParseUint(v, 10, 32); err == nil {
 285                 fmt.Printf("%T, %v\n", s, s)
 286         }
 287         if s, err := strconv.ParseUint(v, 10, 64); err == nil {
 288                 fmt.Printf("%T, %v\n", s, s)
 289         }
 290
 291         // Output:
 292         // uint64, 42
 293         // uint64, 42
 294 }
 295
 296 func ExampleQuote() {
 297         // This string literal contains a tab character.
 298         s := strconv.Quote(`"Fran & Freddie's Diner     ☺"`)
 299         fmt.Println(s)
 300
 301         // Output:
 302         // "\"Fran & Freddie's Diner\t☺\""
 303 }
 304
 305 func ExampleQuoteRune() {
 306         s := strconv.QuoteRune('☺')
 307         fmt.Println(s)
 308
 309         // Output:
 310         // '☺'
 311 }
 312
 313 func ExampleQuoteRuneToASCII() {
 314         s := strconv.QuoteRuneToASCII('☺')
 315         fmt.Println(s)
 316
 317         // Output:
 318         // '\u263a'
 319 }
 320
 321 func ExampleQuoteRuneToGraphic() {
 322         s := strconv.QuoteRuneToGraphic('☺')
 323         fmt.Println(s)
 324
 325         s = strconv.QuoteRuneToGraphic('\u263a')
 326         fmt.Println(s)
 327
 328         s = strconv.QuoteRuneToGraphic('\u000a')
 329         fmt.Println(s)
 330
 331         s = strconv.QuoteRuneToGraphic('        ') // tab character
 332         fmt.Println(s)
 333
 334         // Output:
 335         // '☺'
 336         // '☺'
 337         // '\n'
 338         // '\t'
 339 }
 340
 341 func ExampleQuoteToASCII() {
 342         // This string literal contains a tab character.
 343         s := strconv.QuoteToASCII(`"Fran & Freddie's Diner      ☺"`)
 344         fmt.Println(s)
 345
 346         // Output:
 347         // "\"Fran & Freddie's Diner\t\u263a\""
 348 }
 349
 350 func ExampleQuoteToGraphic() {
 351         s := strconv.QuoteToGraphic("☺")
 352         fmt.Println(s)
 353
 354         // This string literal contains a tab character.
 355         s = strconv.QuoteToGraphic("This is a \u263a    \u000a")
 356         fmt.Println(s)
 357
 358         s = strconv.QuoteToGraphic(`" This is a ☺ \n "`)
 359         fmt.Println(s)
 360
 361         // Output:
 362         // "☺"
 363         // "This is a ☺\t\n"
 364         // "\" This is a ☺ \\n \""
 365 }
 366
 367 func ExampleUnquote() {
 368         s, err := strconv.Unquote("You can't unquote a string without quotes")
 369         fmt.Printf("%q, %v\n", s, err)
 370         s, err = strconv.Unquote("\"The string must be either double-quoted\"")
 371         fmt.Printf("%q, %v\n", s, err)
 372         s, err = strconv.Unquote("`or backquoted.`")
 373         fmt.Printf("%q, %v\n", s, err)
 374         s, err = strconv.Unquote("'\u263a'") // single character only allowed in single quotes
 375         fmt.Printf("%q, %v\n", s, err)
 376         s, err = strconv.Unquote("'\u2639\u2639'")
 377         fmt.Printf("%q, %v\n", s, err)
 378
 379         // Output:
 380         // "", invalid syntax
 381         // "The string must be either double-quoted", <nil>
 382         // "or backquoted.", <nil>
 383         // "☺", <nil>
 384         // "", invalid syntax
 385 }
 386
 387 func ExampleUnquoteChar() {
 388         v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
 389         if err != nil {
 390                 log.Fatal(err)
 391         }
 392
 393         fmt.Println("value:", string(v))
 394         fmt.Println("multibyte:", mb)
 395         fmt.Println("tail:", t)
 396
 397         // Output:
 398         // value: "
 399         // multibyte: false
 400         // tail: Fran & Freddie's Diner\"
 401 }
 402
 403 func ExampleNumError() {
 404         str := "Not a number"
 405         if _, err := strconv.ParseFloat(str, 64); err != nil {
 406                 e := err.(*strconv.NumError)
 407                 fmt.Println("Func:", e.Func)
 408                 fmt.Println("Num:", e.Num)
 409                 fmt.Println("Err:", e.Err)
 410                 fmt.Println(err)
 411         }
 412
 413         // Output:
 414         // Func: ParseFloat
 415         // Num: Not a number
 416         // Err: invalid syntax
 417         // strconv.ParseFloat: parsing "Not a number": invalid syntax
 418 }