Chinaunix首页 | 论坛 | 博客

ly21stly21st.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

ly21st

  • 博客访问： 307460
  • 博文数量： 214
  • 博客积分： 4258
  • 博客等级： 上校
  • 技术积分： 2021
  • 用 户 组： 普通用户
  • 注册时间： 2010-12-02 09:16
个人简介

http://blog.csdn.net/ly21st http://ly21st.blog.chinaunix.net

文章分类

全部博文（214）

文章存档

2018年（16）

2015年（1）

2014年（2）

2012年（22）

2011年（173）

我的朋友
最近访客
推荐博文
相关博文
数字与字符串转换，字符的输出

分类： C/C++

2018-01-30 14:35:58


点击(此处)折叠或打开

  1. // strconv_my project main.go
  2. package main

  4. // Copyright 2015 The Go Authors. All rights reserved.
  5. // Use of this source code is governed by a BSD-style
  6. // license that can be found in the LICENSE file.

  8. import (
  9.     "fmt"
  10.     "log"
  11.     "strconv"
  12. )

  14. func ExampleAppendBool() {
  15.     b := []byte("bool:")
  16.     b = strconv.AppendBool(b, true)
  17.     fmt.Println(string(b))

  19.     // Output:
  20.     // bool:true
  21. }

  23. func ExampleAppendFloat() {
  24.     b32 := []byte("float32:")
  25.     b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
  26.     fmt.Println(string(b32))

  28.     b64 := []byte("float64:")
  29.     b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
  30.     fmt.Println(string(b64))

  32.     // Output:
  33.     // float32:3.1415927E+00
  34.     // float64:3.1415926535E+00
  35. }

  37. func ExampleAppendInt() {
  38.     b10 := []byte("int (base 10):")
  39.     b10 = strconv.AppendInt(b10, -42, 10)
  40.     fmt.Println(string(b10))

  42.     b16 := []byte("int (base 16):")
  43.     b16 = strconv.AppendInt(b16, -42, 16)
  44.     fmt.Println(string(b16))

  46.     // Output:
  47.     // int (base 10):-42
  48.     // int (base 16):-2a
  49. }

  51. func ExampleAppendQuote() {
  52.     b := []byte("quote:")
  53.     b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
  54.     fmt.Println(string(b))

  56.     // Output:
  57.     // quote:"\"Fran & Freddie's Diner\""
  58. }

  60. func ExampleAppendQuoteRune() {
  61.     b := []byte("rune:")
  62.     b = strconv.AppendQuoteRune(b, '?')
  63.     fmt.Println(string(b))

  65.     // Output:
  66.     // rune:'?'
  67. }

  69. func ExampleAppendQuoteRuneToASCII() {
  70.     b := []byte("rune (ascii):")
  71.     b = strconv.AppendQuoteRuneToASCII(b, '?')
  72.     fmt.Println(string(b))

  74.     // Output:
  75.     // rune (ascii):'\u263a'
  76. }

  78. func ExampleAppendQuoteToASCII() {
  79.     b := []byte("quote (ascii):")
  80.     b = strconv.AppendQuoteToASCII(b, `"Fran & Freddie's Diner"`)
  81.     fmt.Println(string(b))

  83.     // Output:
  84.     // quote (ascii):"\"Fran & Freddie's Diner\""
  85. }

  87. func ExampleAppendUint() {
  88.     b10 := []byte("uint (base 10):")
  89.     b10 = strconv.AppendUint(b10, 42, 10)
  90.     fmt.Println(string(b10))

  92.     b16 := []byte("uint (base 16):")
  93.     b16 = strconv.AppendUint(b16, 42, 16)
  94.     fmt.Println(string(b16))

  96.     // Output:
  97.     // uint (base 10):42
  98.     // uint (base 16):2a
  99. }

  101. func ExampleAtoi() {
  102.     v := "10"
  103.     if s, err := strconv.Atoi(v); err == nil {
  104.         fmt.Printf("%T, %v", s, s)
  105.     }

  107.     // Output:
  108.     // int, 10
  109. }

  111. func ExampleCanBackquote() {
  112.     fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ?"))
  113.     fmt.Println(strconv.CanBackquote("`can't backquote this`"))

  115.     // Output:
  116.     // true
  117.     // false
  118. }

  120. func ExampleFormatBool() {
  121.     v := true
  122.     s := strconv.FormatBool(v)
  123.     fmt.Printf("%T, %v\n", s, s)

  125.     // Output:
  126.     // string, true
  127. }

  129. func ExampleFormatFloat() {
  130.     v := 3.1415926535

  132.     s32 := strconv.FormatFloat(v, 'E', -1, 32)
  133.     fmt.Printf("%T, %v\n", s32, s32)

  135.     s64 := strconv.FormatFloat(v, 'E', -1, 64)
  136.     fmt.Printf("%T, %v\n", s64, s64)

  138.     // Output:
  139.     // string, 3.1415927E+00
  140.     // string, 3.1415926535E+00
  141. }

  143. func ExampleFormatInt() {
  144.     v := int64(-42)

  146.     s10 := strconv.FormatInt(v, 10)
  147.     fmt.Printf("%T, %v\n", s10, s10)

  149.     s16 := strconv.FormatInt(v, 16)
  150.     fmt.Printf("%T, %v\n", s16, s16)

  152.     // Output:
  153.     // string, -42
  154.     // string, -2a
  155. }

  157. func ExampleFormatUint() {
  158.     v := uint64(42)

  160.     s10 := strconv.FormatUint(v, 10)
  161.     fmt.Printf("%T, %v\n", s10, s10)

  163.     s16 := strconv.FormatUint(v, 16)
  164.     fmt.Printf("%T, %v\n", s16, s16)

  166.     // Output:
  167.     // string, 42
  168.     // string, 2a
  169. }

  171. func ExampleIsPrint() {
  172.     c := strconv.IsPrint('\u263a')
  173.     fmt.Println(c)

  175.     bel := strconv.IsPrint('\007')
  176.     fmt.Println(bel)

  178.     // Output:
  179.     // true
  180.     // false
  181. }

  183. func ExampleItoa() {
  184.     i := 10
  185.     s := strconv.Itoa(i)
  186.     fmt.Printf("%T, %v\n", s, s)

  188.     // Output:
  189.     // string, 10
  190. }

  192. func ExampleParseBool() {
  193.     v := "true"
  194.     if s, err := strconv.ParseBool(v); err == nil {
  195.         fmt.Printf("%T, %v\n", s, s)
  196.     }

  198.     // Output:
  199.     // bool, true
  200. }

  202. func ExampleParseFloat() {
  203.     v := "3.1415926535"
  204.     if s, err := strconv.ParseFloat(v, 32); err == nil {
  205.         fmt.Printf("%T, %v\n", s, s)
  206.     }
  207.     if s, err := strconv.ParseFloat(v, 64); err == nil {
  208.         fmt.Printf("%T, %v\n", s, s)
  209.     }

  211.     // Output:
  212.     // float64, 3.1415927410125732
  213.     // float64, 3.1415926535
  214. }

  216. func ExampleParseInt() {
  217.     v32 := "-354634382"
  218.     if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
  219.         fmt.Printf("%T, %v\n", s, s)
  220.     }
  221.     if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
  222.         fmt.Printf("%T, %v\n", s, s)
  223.     }

  225.     v64 := "-3546343826724305832"
  226.     if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
  227.         fmt.Printf("%T, %v\n", s, s)
  228.     }
  229.     if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
  230.         fmt.Printf("%T, %v\n", s, s)
  231.     }

  233.     // Output:
  234.     // int64, -354634382
  235.     // int64, -3546343826724305832
  236. }

  238. func ExampleParseUint() {
  239.     v := "42"
  240.     if s, err := strconv.ParseUint(v, 10, 32); err == nil {
  241.         fmt.Printf("%T, %v\n", s, s)
  242.     }
  243.     if s, err := strconv.ParseUint(v, 10, 64); err == nil {
  244.         fmt.Printf("%T, %v\n", s, s)
  245.     }

  247.     // Output:
  248.     // uint64, 42
  249.     // uint64, 42
  250. }

  252. func ExampleQuote() {
  253.     s := strconv.Quote(`"Fran & Freddie's Diner    ?"`)
  254.     fmt.Println(s)

  256.     // Output:
  257.     // "\"Fran & Freddie's Diner\t?\""
  258. }

  260. func ExampleQuoteRune() {
  261.     s := strconv.QuoteRune('?')
  262.     fmt.Println(s)

  264.     // Output:
  265.     // '?'
  266. }

  268. func ExampleQuoteRuneToASCII() {
  269.     s := strconv.QuoteRuneToASCII('?')
  270.     fmt.Println(s)

  272.     // Output:
  273.     // '\u263a'
  274. }

  276. func ExampleQuoteToASCII() {
  277.     s := strconv.QuoteToASCII(`"Fran & Freddie's Diner    ?"`)
  278.     fmt.Println(s)

  280.     // Output:
  281.     // "\"Fran & Freddie's Diner\t\u263a\""
  282. }

  284. func ExampleUnquote() {
  285.     test := func(s string) {
  286.         t, err := strconv.Unquote(s)
  287.         if err != nil {
  288.             fmt.Printf("Unquote(%#v): %v\n", s, err)
  289.         } else {
  290.             fmt.Printf("Unquote(%#v) = %v\n", s, t)
  291.         }
  292.     }

  294.     s := `\"Fran & Freddie's Diner\t\u263a\"\"`
  295.     // If the string doesn't have quotes, it can't be unquoted.
  296.     test(s) // invalid syntax
  297.     test("`" + s + "`")
  298.     test(`"` + s + `"`)
  299.     test(`'\u263a'`)

  301.     // Output:
  302.     // Unquote("\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\""): invalid syntax
  303.     // Unquote("`\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"`") = \"Fran & Freddie's Diner\t\u263a\"\"
  304.     // Unquote("\"\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"\"") = "Fran & Freddie's Diner    ?""
  305.     // Unquote("'\\u263a'") = ?
  306. }

  308. func ExampleUnquoteChar() {
  309.     v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
  310.     if err != nil {
  311.         log.Fatal(err)
  312.     }

  314.     fmt.Println("value:", string(v))
  315.     fmt.Println("multibyte:", mb)
  316.     fmt.Println("tail:", t)

  318.     // Output:
  319.     // value: "
  320.     // multibyte: false
  321.     // tail: Fran & Freddie's Diner\"
  322. }

  324. func ExampleNumError() {
  325.     str := "Not a number"
  326.     if _, err := strconv.ParseFloat(str, 64); err != nil {
  327.         e := err.(*strconv.NumError)
  328.         fmt.Println("Func:", e.Func)
  329.         fmt.Println("Num:", e.Num)
  330.         fmt.Println("Err:", e.Err)
  331.         fmt.Println(err)
  332.     }

  334.     // Output:
  335.     // Func: ParseFloat
  336.     // Num: Not a number
  337.     // Err: invalid syntax
  338.     // strconv.ParseFloat: parsing "Not a number": invalid syntax
  339. }

  341. func main() {
  342.     fmt.Println("---begin test ExampleAppendBool---")
  343.     ExampleAppendBool()
  344.     fmt.Println("### end test ExampleAppendBool ###\n")

  346.     fmt.Println("---begin test ExampleAppendFloat---")
  347.     ExampleAppendFloat()
  348.     fmt.Println("### end test ExampleAppendFloat ###\n")

  350.     fmt.Println("---begin test ExampleAppendInt---")
  351.     ExampleAppendInt()
  352.     fmt.Println("### end test ExampleAppendInt ###\n")

  354.     fmt.Println("---begin test ExampleAppendQuote---")
  355.     ExampleAppendQuote()
  356.     fmt.Println("### end test ExampleAppendQuote ###\n")

  358.     fmt.Println("---begin test ExampleAppendQuoteRune---")
  359.     ExampleAppendQuoteRune()
  360.     fmt.Println("### end test ExampleAppendQuoteRune ###\n")

  362.     fmt.Println("---begin test ExampleAppendQuoteRuneToASCII---")
  363.     ExampleAppendQuoteRuneToASCII()
  364.     fmt.Println("### end test ExampleAppendQuoteRuneToASCII ###\n")

  366.     fmt.Println("---begin test ExampleAppendQuoteToASCII---")
  367.     ExampleAppendQuoteToASCII()
  368.     fmt.Println("### end test ExampleAppendQuoteToASCII ###\n")

  370.     fmt.Println("---begin test ExampleAppendUint---")
  371.     ExampleAppendUint()
  372.     fmt.Println("### end test ExampleAppendUint ###\n")

  374.     fmt.Println("---begin test ExampleAtoi---")
  375.     ExampleAtoi()
  376.     fmt.Println("### end test ExampleAtoi ###\n")

  378.     fmt.Println("---begin test ExampleCanBackquote---")
  379.     ExampleCanBackquote()
  380.     fmt.Println("### end test ExampleCanBackquote ###\n")

  382.     fmt.Println("---begin test ExampleFormatBool---")
  383.     ExampleFormatBool()
  384.     fmt.Println("### end test ExampleFormatBool ###\n")

  386.     fmt.Println("---begin test ExampleFormatFloat---")
  387.     ExampleFormatFloat()
  388.     fmt.Println("### end test ExampleFormatFloat ###\n")

  390.     fmt.Println("---begin test ExampleFormatInt---")
  391.     ExampleFormatInt()
  392.     fmt.Println("### end test ExampleFormatInt ###\n")

  394.     fmt.Println("---begin test ExampleFormatUint---")
  395.     ExampleFormatUint()
  396.     fmt.Println("### end test ExampleFormatUint ###\n")

  398.     fmt.Println("---begin test ExampleIsPrint---")
  399.     ExampleIsPrint()
  400.     fmt.Println("### end test ExampleIsPrint ###\n")

  402.     fmt.Println("---begin test ExampleItoa---")
  403.     ExampleItoa()

  405.     fmt.Println("---begin test ExampleParseBool---")
  406.     ExampleParseBool()

  408.     fmt.Println("---begin test ExampleParseFloat---")
  409.     ExampleParseFloat()

  411.     fmt.Println("---begin test ExampleParseInt---")
  412.     ExampleParseInt()

  414.     fmt.Println("---begin test ExampleParseUint---")
  415.     ExampleParseUint()

  417.     fmt.Println("---begin test ExampleQuote---")
  418.     ExampleQuote()

  420.     fmt.Println("---begin test ExampleQuoteRune---")
  421.     ExampleQuoteRune()

  423.     fmt.Println("---begin test ExampleQuoteRuneToASCII---")
  424.     ExampleQuoteRuneToASCII()

  426.     fmt.Println("---begin test ExampleQuoteToASCII---")
  427.     ExampleQuoteToASCII()

  429.     fmt.Println("---begin test ExampleUnquote---")
  430.     ExampleUnquote()

  432.     fmt.Println("---begin test ExampleUnquoteChar---")
  433.     ExampleUnquoteChar()

  435.     fmt.Println("---begin test ExampleNumError---
  436.     ExampleNumError() 
    }
结果输出：
---begin test ExampleAppendBool---
bool:true
### end test ExampleAppendBool ###
---begin test ExampleAppendFloat---
float32:3.1415927E+00
float64:3.1415926535E+00
### end test ExampleAppendFloat ###
---begin test ExampleAppendInt---
int (base 10):-42
int (base 16):-2a
### end test ExampleAppendInt ###
---begin test ExampleAppendQuote---
quote:"\"Fran & Freddie's Diner\""
### end test ExampleAppendQuote ###
---begin test ExampleAppendQuoteRune---
rune:'?'
### end test ExampleAppendQuoteRune ###
---begin test ExampleAppendQuoteRuneToASCII---
rune (ascii):'\u263a'
### end test ExampleAppendQuoteRuneToASCII ###
---begin test ExampleAppendQuoteToASCII---
quote (ascii):"\"Fran & Freddie's Diner\""
### end test ExampleAppendQuoteToASCII ###
---begin test ExampleAppendUint---
uint (base 10):42
uint (base 16):2a
### end test ExampleAppendUint ###
---begin test ExampleAtoi---
int, 10### end test ExampleAtoi ###
---begin test ExampleCanBackquote---
true
false
### end test ExampleCanBackquote ###
---begin test ExampleFormatBool---
string, true
### end test ExampleFormatBool ###
---begin test ExampleFormatFloat---
string, 3.1415927E+00
string, 3.1415926535E+00
### end test ExampleFormatFloat ###
---begin test ExampleFormatInt---
string, -42
string, -2a
### end test ExampleFormatInt ###
---begin test ExampleFormatUint---
string, 42
string, 2a
### end test ExampleFormatUint ###
---begin test ExampleIsPrint---
true
false
### end test ExampleIsPrint ###
---begin test ExampleItoa---
string, 10
---begin test ExampleParseBool---
bool, true
---begin test ExampleParseFloat---
float64, 3.1415927410125732
float64, 3.1415926535
---begin test ExampleParseInt---
int64, -354634382
int64, -3546343826724305832
---begin test ExampleParseUint---
uint64, 42
uint64, 42
---begin test ExampleQuote---
"\"Fran & Freddie's Diner\t?\""
---begin test ExampleQuoteRune---
'?'
---begin test ExampleQuoteRuneToASCII---
'\u263a'
---begin test ExampleQuoteToASCII---
"\"Fran & Freddie's Diner\t\u263a\""
---begin test ExampleUnquote---
Unquote("\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\""): invalid syntax
Unquote("`\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"`") = \"Fran & Freddie's Diner\t\u263a\"\"
Unquote("\"\\\"Fran & Freddie's Diner\\t\\u263a\\\"\\\"\"") = "Fran & Freddie's Diner ?""
Unquote("'\\u263a'") = ?
---begin test ExampleUnquoteChar---
value: "
multibyte: false
tail: Fran & Freddie's Diner\"
成功: 进程退出代码 0.


阅读(488) | 评论(0) | 转发(0) |
0

上一篇：时间处理

下一篇：在若干协程中只执行一次函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6