example_test.go

Documentation: 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 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  }
	 419
View as plain text