Dan Willemsen | 09eb3b1 | 2015-09-16 14:34:17 -0700 | [diff] [blame] | 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 | } |