Home | History | Annotate | Download | only in strconv 
      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 ExampleIsPrint() {
    171 	c := strconv.IsPrint('\u263a')
    172 	fmt.Println(c)
    173 
    174 	bel := strconv.IsPrint('\007')
    175 	fmt.Println(bel)
    176 
    177 	// Output:
    178 	// true
    179 	// false
    180 }
    181 
    182 func ExampleItoa() {
    183 	i := 10
    184 	s := strconv.Itoa(i)
    185 	fmt.Printf("%T, %v\n", s, s)
    186 
    187 	// Output:
    188 	// string, 10
    189 }
    190 
    191 func ExampleParseBool() {
    192 	v := "true"
    193 	if s, err := strconv.ParseBool(v); err == nil {
    194 		fmt.Printf("%T, %v\n", s, s)
    195 	}
    196 
    197 	// Output:
    198 	// bool, true
    199 }
    200 
    201 func ExampleParseFloat() {
    202 	v := "3.1415926535"
    203 	if s, err := strconv.ParseFloat(v, 32); err == nil {
    204 		fmt.Printf("%T, %v\n", s, s)
    205 	}
    206 	if s, err := strconv.ParseFloat(v, 64); err == nil {
    207 		fmt.Printf("%T, %v\n", s, s)
    208 	}
    209 
    210 	// Output:
    211 	// float64, 3.1415927410125732
    212 	// float64, 3.1415926535
    213 }
    214 
    215 func ExampleParseInt() {
    216 	v32 := "-354634382"
    217 	if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
    218 		fmt.Printf("%T, %v\n", s, s)
    219 	}
    220 	if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
    221 		fmt.Printf("%T, %v\n", s, s)
    222 	}
    223 
    224 	v64 := "-3546343826724305832"
    225 	if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
    226 		fmt.Printf("%T, %v\n", s, s)
    227 	}
    228 	if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
    229 		fmt.Printf("%T, %v\n", s, s)
    230 	}
    231 
    232 	// Output:
    233 	// int64, -354634382
    234 	// int64, -3546343826724305832
    235 }
    236 
    237 func ExampleParseUint() {
    238 	v := "42"
    239 	if s, err := strconv.ParseUint(v, 10, 32); err == nil {
    240 		fmt.Printf("%T, %v\n", s, s)
    241 	}
    242 	if s, err := strconv.ParseUint(v, 10, 64); err == nil {
    243 		fmt.Printf("%T, %v\n", s, s)
    244 	}
    245 
    246 	// Output:
    247 	// uint64, 42
    248 	// uint64, 42
    249 }
    250 
    251 func ExampleQuote() {
    252 	s := strconv.Quote(`"Fran & Freddie's Diner	"`)
    253 	fmt.Println(s)
    254 
    255 	// Output:
    256 	// "\"Fran & Freddie's Diner\t\""
    257 }
    258 
    259 func ExampleQuoteRune() {
    260 	s := strconv.QuoteRune('')
    261 	fmt.Println(s)
    262 
    263 	// Output:
    264 	// ''
    265 }
    266 
    267 func ExampleQuoteRuneToASCII() {
    268 	s := strconv.QuoteRuneToASCII('')
    269 	fmt.Println(s)
    270 
    271 	// Output:
    272 	// '\u263a'
    273 }
    274 
    275 func ExampleQuoteToASCII() {
    276 	s := strconv.QuoteToASCII(`"Fran & Freddie's Diner	"`)
    277 	fmt.Println(s)
    278 
    279 	// Output:
    280 	// "\"Fran & Freddie's Diner\t\u263a\""
    281 }
    282 
    283 func ExampleUnquote() {
    284 	test := func(s string) {
    285 		t, err := strconv.Unquote(s)
    286 		if err != nil {
    287 			fmt.Printf("Unquote(%#v): %v\n", s, err)
    288 		} else {
    289 			fmt.Printf("Unquote(%#v) = %v\n", s, t)
    290 		}
    291 	}
    292 
    293 	s := `\"Fran & Freddie's Diner\t\u263a\"\"`
    294 	// If the string doesn't have quotes, it can't be unquoted.
    295 	test(s) // invalid syntax
    296 	test("`" + s + "`")
    297 	test(`"` + s + `"`)
    298 	test(`'\u263a'`)
    299 
    300 	// Output:
    301 	// Unquote("\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\""): invalid syntax
    302 	// Unquote("`\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"`") = \"Fran & Freddie's Diner\t\u263a\"\"
    303 	// Unquote("\"\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"\"") = "Fran & Freddie's Diner	""
    304 	// Unquote("'\\u263a'") = 
    305 }
    306 
    307 func ExampleUnquoteChar() {
    308 	v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
    309 	if err != nil {
    310 		log.Fatal(err)
    311 	}
    312 
    313 	fmt.Println("value:", string(v))
    314 	fmt.Println("multibyte:", mb)
    315 	fmt.Println("tail:", t)
    316 
    317 	// Output:
    318 	// value: "
    319 	// multibyte: false
    320 	// tail: Fran & Freddie's Diner\"
    321 }
    322 
    323 func ExampleNumError() {
    324 	str := "Not a number"
    325 	if _, err := strconv.ParseFloat(str, 64); err != nil {
    326 		e := err.(*strconv.NumError)
    327 		fmt.Println("Func:", e.Func)
    328 		fmt.Println("Num:", e.Num)
    329 		fmt.Println("Err:", e.Err)
    330 		fmt.Println(err)
    331 	}
    332 
    333 	// Output:
    334 	// Func: ParseFloat
    335 	// Num: Not a number
    336 	// Err: invalid syntax
    337 	// strconv.ParseFloat: parsing "Not a number": invalid syntax
    338 }
    339