github.com/mdempsky/go@v0.0.0-20151201204031-5dd372bd1e70/src/strconv/example_test.go (about)

     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  }