int--string
|
1
2
3
4
|
//string到int
value_int,err:=strconv.Atoi(string)
//int到string
str:=strconv.Itoa(value_int)
|
int64--string
|
1
2
3
4
5
6
|
//string到int64
value_int64, err := strconv.ParseInt(string, 10, 64)
//int64到string,需注意下面转换规定
//FormatInt returns the string representation of i in the given base, for 2 <= base <= 36.
//The result uses the lower-case letters 'a' to 'z' for digit values >= 10
str:=strconv.FormatInt(value_int64,10)<br>
//FormatInt第二个参数表示进制，10表示十进制。
|
float--string
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
//float转string
v := 3.1415926535
s1 := strconv.FormatFloat(v,
'E'
, -1, 32)
//float32s2 := strconv.FormatFloat(v, 'E', -1, 64)//float64
//第二个参数可选'f'/'e'/'E'等，含义如下：
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
//string转float
s :=
"3.1415926535"
v1, err := strconv.ParseFloat(v, 32)
v2, err := strconv.ParseFloat(v, 64)
|
float--int
|
1
2
3
4
5
6
7
8
9
10
11
|
//这个就很简单了
var
a int64
a = 1
var
b float64
b = 2.000
//a -- float64
c := float64(a)
//b -- int64
d := int64(b)
|
//interface{}到float64-------接口后加上 .(float64) //interface{}到string-------接口后加上 .(string)
下面是关于golang strconv的使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
|
// atob.go
------------------------------------------------------------
// ParseBool 将字符串转换为布尔值
// 它接受真值：1, t, T, TRUE, true, True
// 它接受假值：0, f, F, FALSE, false, False.
// 其它任何值都返回一个错误
func
ParseBool(str string) (value bool, err error)
func
main() {
fmt.Println(strconv.ParseBool(
"1"
))
// true
fmt.Println(strconv.ParseBool(
"t"
))
// true
fmt.Println(strconv.ParseBool(
"T"
))
// true
fmt.Println(strconv.ParseBool(
"true"
))
// true
fmt.Println(strconv.ParseBool(
"True"
))
// true
fmt.Println(strconv.ParseBool(
"TRUE"
))
// true
fmt.Println(strconv.ParseBool(
"TRue"
))
// false strconv.ParseBool: parsing "TRue": invalid syntax
fmt.Println(strconv.ParseBool(
"0"
))
// false
fmt.Println(strconv.ParseBool(
"f"
))
// false
fmt.Println(strconv.ParseBool(
"F"
))
// false
fmt.Println(strconv.ParseBool(
"false"
))
// false
fmt.Println(strconv.ParseBool(
"False"
))
// false
fmt.Println(strconv.ParseBool(
"FALSE"
))
// false
fmt.Println(strconv.ParseBool(
"FALse"
))
// false strconv.ParseBool: parsing "FAlse": invalid syntax
}
------------------------------------------------------------
// FormatBool 将布尔值转换为字符串 "true" 或 "false"
func
FormatBool(b bool) string
func
main() {
fmt.Println(strconv.FormatBool(0 < 1))
// true
fmt.Println(strconv.FormatBool(0 > 1))
// false
}
------------------------------------------------------------
// AppendBool 将布尔值 b 转换为字符串 "true" 或 "false"
// 然后将结果追加到 dst 的尾部，返回追加后的 []bytefunc
AppendBool(dst []byte, b bool) []byte
func
main() {
rst := make([]byte, 0)
rst = strconv.AppendBool(rst, 0 < 1)
fmt.Printf(
"%s\n"
, rst)
// true
rst = strconv.AppendBool(rst, 0 > 1)
fmt.Printf(
"%s\n"
, rst)
// truefalse
}
============================================================
// atof.go
------------------------------------------------------------
// ParseFloat 将字符串转换为浮点数
// s：要转换的字符串
// bitSize：指定浮点类型（32:float32、64:float64）
// 如果 s 是合法的格式，而且接近一个浮点值，
// 则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）
// 如果 s 不是合法的格式，则返回“语法错误”
// 如果转换结果超出 bitSize 范围，则返回“超出范围”
func
ParseFloat(s string, bitSize int) (f float64, err error)
func
main() {
s :=
"0.12345678901234567890"
f, err := strconv.ParseFloat(s, 32)
fmt.Println(f, err)
// 0.12345679104328156
fmt.Println(float32(f), err)
// 0.12345679
f, err = strconv.ParseFloat(s, 64)
fmt.Println(f, err)
// 0.12345678901234568
}
============================================================
// atoi.go
------------------------------------------------------------
// ErrRange 表示值超出范围var ErrRange = errors.New("value out of range")
// ErrSyntax 表示语法不正确var ErrSyntax = errors.New("invalid syntax")
// NumError 记录转换失败
type
NumError
struct
{
Func string
// 失败的函数名(ParseBool, ParseInt, ParseUint, ParseFloat)
Num string
// 输入的值
Err error
// 失败的原因(ErrRange, ErrSyntax)
}
// int 或 uint 类型的长度(32 或 64)
const
IntSize = intSize
const
intSize = 32 << uint(^uint(0)>>63)
// 实现 Error 接口，输出错误信息
func
(e *NumError) Error() string
------------------------------------------------------------
// ParseInt 将字符串转换为 int 类型
// s：要转换的字符串
// base：进位制（2 进制到 36 进制）
// bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
// 返回转换后的结果和转换时遇到的错误
// 如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）
func
ParseInt(s string, base int, bitSize int) (i int64, err error)
func
main() {
fmt.Println(strconv.ParseInt(
"123"
, 10, 8))
// 123
fmt.Println(strconv.ParseInt(
"12345"
, 10, 8))
// 127 strconv.ParseInt: parsing "12345": value out of range
fmt.Println(strconv.ParseInt(
"2147483647"
, 10, 0))
// 2147483647
fmt.Println(strconv.ParseInt(
"0xFF"
, 16, 0))
// 0 strconv.ParseInt: parsing "0xFF": invalid syntax
fmt.Println(strconv.ParseInt(
"FF"
, 16, 0))
// 255
fmt.Println(strconv.ParseInt(
"0xFF"
, 0, 0))
// 255
}
------------------------------------------------------------
// ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数
func
ParseUint(s string, base int, bitSize int) (n uint64, err error)
func
main() {
fmt.Println(strconv.ParseUint(
"FF"
, 16, 8))
// 255
}
------------------------------------------------------------
// Atoi 相当于 ParseInt(s, 10, 0)
// 通常使用这个函数，而不使用
ParseIntfunc Atoi(s string) (i int, err error)
func
main() {
fmt.Println(strconv.Atoi(
"2147483647"
))
// 2147483647
fmt.Println(strconv.Atoi(
"2147483648"
))
// 2147483647 strconv.ParseInt: parsing "2147483648": value out of range
}
============================================================
// ftoa.go
------------------------------------------------------------
// FormatFloat 将浮点数 f 转换为字符串值
// f：要转换的浮点数
// fmt：格式标记（b、e、E、f、g、G）
// prec：精度（数字部分的长度，不包括指数部分）
// bitSize：指定浮点类型（32:float32、64:float64）
//// 格式标记：
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
//// 如果格式标记为 'e'，'E'和'f'，则 prec 表示小数点后的数字位数
// 如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）
func
FormatFloat(f float64, fmt byte, prec, bitSize int) string
func
main() {
f := 100.12345678901234567890123456789
fmt.Println(strconv.FormatFloat(f,
'b'
, 5, 32))
// 13123382p-17
fmt.Println(strconv.FormatFloat(f,
'e'
, 5, 32))
// 1.00123e+02
fmt.Println(strconv.FormatFloat(f,
'E'
, 5, 32))
// 1.00123E+02
fmt.Println(strconv.FormatFloat(f,
'f'
, 5, 32))
// 100.12346
fmt.Println(strconv.FormatFloat(f,
'g'
, 5, 32))
// 100.12
fmt.Println(strconv.FormatFloat(f,
'G'
, 5, 32))
// 100.12
fmt.Println(strconv.FormatFloat(f,
'b'
, 30, 32))
// 13123382p-17
fmt.Println(strconv.FormatFloat(f,
'e'
, 30, 32))
// 1.001234588623046875000000000000e+02
fmt.Println(strconv.FormatFloat(f,
'E'
, 30, 32))
// 1.001234588623046875000000000000E+02
fmt.Println(strconv.FormatFloat(f,
'f'
, 30, 32))
// 100.123458862304687500000000000000
fmt.Println(strconv.FormatFloat(f,
'g'
, 30, 32))
// 100.1234588623046875
fmt.Println(strconv.FormatFloat(f,
'G'
, 30, 32))
// 100.1234588623046875
}
------------------------------------------------------------
// AppendFloat 将浮点数 f 转换为字符串值，并将转换结果追加到 dst 的尾部
// 返回追加后的 []bytefunc
AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte
func
main() {
f := 100.12345678901234567890123456789
b := make([]byte, 0)
b = strconv.AppendFloat(b, f,
'f'
, 5, 32)
b = append(b,
" "
...)
b = strconv.AppendFloat(b, f,
'e'
, 5, 32)
fmt.Printf(
"%s"
, b)
// 100.12346 1.00123e+0
}
============================================================
// itoa.go
------------------------------------------------------------
// FormatUint 将 int 型整数 i 转换为字符串形式
// base：进位制（2 进制到 36 进制）
// 大于 10 进制的数，返回值使用小写字母 'a' 到 'z'func
FormatInt(i int64, base int) string
func
main() {
i := int64(-2048)
fmt.Println(strconv.FormatInt(i, 2))
// -100000000000
fmt.Println(strconv.FormatInt(i, 8))
// -4000
fmt.Println(strconv.FormatInt(i, 10))
// -2048
fmt.Println(strconv.FormatInt(i, 16))
// -800
fmt.Println(strconv.FormatInt(i, 36))
// -1kw
}
------------------------------------------------------------
// FormatUint 将 uint 型整数 i 转换为字符串形式
// base：进位制（2 进制到 36 进制）
// 大于 10 进制的数，返回值使用小写字母 'a' 到 'z'func
FormatUint(i uint64, base int) string
func
main() {
i := uint64(2048)
fmt.Println(strconv.FormatUint(i, 2))
// 100000000000
fmt.Println(strconv.FormatUint(i, 8))
// 4000
fmt.Println(strconv.FormatUint(i, 10))
// 2048
fmt.Println(strconv.FormatUint(i, 16))
// 800
fmt.Println(strconv.FormatUint(i, 36))
// 1kw
}
------------------------------------------------------------
// Itoa 相当于 FormatInt(i, 10)func Itoa(i int) string
func
main() {
fmt.Println(strconv.Itoa(-2048))
// -2048
fmt.Println(strconv.Itoa(2048))
// 2048
}
------------------------------------------------------------
// AppendInt 将 int 型整数 i 转换为字符串形式，并追加到 dst 的尾部
// i：要转换的字符串
// base：进位制
// 返回追加后的 []bytefunc
AppendInt(dst []byte, i int64, base int) []byte
func
main() {
b := make([]byte, 0)
b = strconv.AppendInt(b, -2048, 16)
fmt.Printf(
"%s"
, b)
// -800
}
------------------------------------------------------------
// AppendUint 将 uint 型整数 i 转换为字符串形式，并追加到 dst 的尾部
// i：要转换的字符串
// base：进位制
// 返回追加后的 []bytefunc
AppendUint(dst []byte, i uint64, base int) []byte
func
main() {
b := make([]byte, 0)
b = strconv.AppendUint(b, 2048, 16)
fmt.Printf(
"%s"
, b)
// 800
}
============================================================
// quote.go
------------------------------------------------------------
// Quote 将字符串 s 转换为“双引号”引起来的字符串
// 其中的特殊字符将被转换为“转义字符”
// “不可显示的字符”将被转换为“转义字符”
func
Quote(s string) string
func
main() {
fmt.Println(strconv.Quote(`C:\Windows`))
// "C:\\Windows"
}
------------------------------------------------------------
// AppendQuote 将字符串 s 转换为“双引号”引起来的字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// 其中的特殊字符将被转换为“转义字符”func
AppendQuote(dst []byte, s string) []byte
func
main() {
s := `C:\Windows`
b := make([]byte, 0)
b = strconv.AppendQuote(b, s)
fmt.Printf(
"%s"
, b)
// "C:\\Windows"
}
------------------------------------------------------------
// QuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func
QuoteToASCII(s string) string
func
main() {
fmt.Println(strconv.QuoteToASCII(
"Hello 世界！"
))
// "Hello \u4e16\u754c\uff01"
}
------------------------------------------------------------
// AppendQuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func
AppendQuoteToASCII(dst []byte, s string) []byte
func
main() {
s :=
"Hello 世界！"
b := make([]byte, 0)
b = strconv.AppendQuoteToASCII(b, s)
fmt.Printf(
"%s"
, b)
// "Hello \u4e16\u754c\uff01"
}
------------------------------------------------------------
// QuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串
// “特殊字符”将被转换为“转义字符”
func
QuoteRune(r rune) string
func
main() {
fmt.Println(strconv.QuoteRune(
'好'
))
// '好'
}
------------------------------------------------------------
// AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “特殊字符”将被转换为“转义字符”
func
AppendQuoteRune(dst []byte, r rune) []byte
func
main() {
b := make([]byte, 0)
b = strconv.AppendQuoteRune(b,
'好'
)
fmt.Printf(
"%s"
, b)
// '好'
}
------------------------------------------------------------
// QuoteRuneToASCII 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func
QuoteRuneToASCII(r rune) string
func
main() {
fmt.Println(strconv.QuoteRuneToASCII(
'好'
))
// '\u597d'
}
------------------------------------------------------------
// AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func
AppendQuoteRuneToASCII(dst []byte, r rune) []byte
func
main() {
b := make([]byte, 0)
b = strconv.AppendQuoteRuneToASCII(b,
'好'
)
fmt.Printf(
"%s"
, b)
// '\u597d'
}
------------------------------------------------------------
// CanBackquote 判断字符串 s 是否可以表示为一个单行的“反引号”字符串
// 字符串中不能含有控制字符（除了 \t）和“反引号”字符，否则返回 false
func
CanBackquote(s string) bool
func
main() {
b := strconv.CanBackquote(
"C:\\Windows\n"
)
fmt.Println(b)
// false
b = strconv.CanBackquote(
"C:\\Windows\r"
)
fmt.Println(b)
// false
b = strconv.CanBackquote(
"C:\\Windows\f"
)
fmt.Println(b)
// false
b = strconv.CanBackquote(
"C:\\Windows\t"
)
fmt.Println(b)
// true
b = strconv.CanBackquote(
"C:\\`Windows`"
)
fmt.Println(b)
// false
}
------------------------------------------------------------
// UnquoteChar 将 s 中的第一个字符“取消转义”并解码
//// s：转义后的字符串
// quote：字符串使用的“引号符”（用于对引号符“取消转义”）
//// value： 解码后的字符
// multibyte：value 是否为多字节字符
// tail： 字符串 s 除去 value 后的剩余部分
// error： 返回 s 中是否存在语法错误
//// 参数 quote 为“引号符”
// 如果设置为单引号，则 s 中允许出现 \' 字符，不允许出现单独的 ' 字符
// 如果设置为双引号，则 s 中允许出现 \" 字符，不允许出现单独的 " 字符
// 如果设置为 0，则不允许出现 \' 或 \" 字符，可以出现单独的 ' 或 " 字符
func
UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)
func
main() {
s := `\"大\\家\\好！\"`
c, mb, sr, _ := strconv.UnquoteChar(s,
'"'
)
fmt.Printf(
"%-3c %v\n"
, c, mb)
for
; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr,
'"'
) {
fmt.Printf(
"%-3c %v\n"
, c, mb)
}
// " false
// 大 true
// \ false
// 家 true
// \ false
// 好 true
// ！ true
}
------------------------------------------------------------
// Unquote 将“带引号的字符串” s 转换为常规的字符串（不带引号和转义字符）
// s 可以是“单引号”、“双引号”或“反引号”引起来的字符串（包括引号本身）
// 如果 s 是单引号引起来的字符串，则返回该该字符串代表的字符
func
Unquote(s string) (t string, err error)
func
main() {
sr, err := strconv.Unquote(`
"\"大\t家\t好！\""
`)
fmt.Println(sr, err)
sr, err = strconv.Unquote(`
'大家好！'
`)
fmt.Println(sr, err)
sr, err = strconv.Unquote(`
'好'
`)
fmt.Println(sr, err)
sr, err = strconv.Unquote(
"`大\\t家\\t好！`"
)
fmt.Println(sr, err)
}
------------------------------------------------------------
// IsPrint 判断 Unicode 字符 r 是否是一个可显示的字符
// 可否显示并不是你想象的那样，比如空格可以显示，而\t则不能显示
// 具体可以参考 Go 语言的源码
func
IsPrint(r rune) bool
func
main() {
fmt.Println(strconv.IsPrint(
'a'
))
// true
fmt.Println(strconv.IsPrint(
'好'
))
// true
fmt.Println(strconv.IsPrint(
' '
))
// true
fmt.Println(strconv.IsPrint(
'\t'
))
// false
fmt.Println(strconv.IsPrint(
'\n'
))
// false
fmt.Println(strconv.IsPrint(0))
// false
}
|