golang数据类型转换
int--string
//string到int
value_int,err:=strconv.Atoi(string)
//int到string
str:=strconv.Itoa(value_int)
int64--string
//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)
//FormatInt第二个参数表示进制，10表示十进制。
float--string
//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
//这个就很简单了
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的使用
// 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
}
golang数据类型转换的更多相关文章
- Golang的类型转换实战案例
Golang的类型转换实战案例 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.数据类型概述 基础数据类型概述,博主推荐阅读: 布尔型: https://www.cnblogs. ...
- JavaScript中数据类型转换总结
JavaScript中数据类型转换总结 在js中,数据类型转换分为显式数据类型转换和隐式数据类型转换. 1, 显式数据类型转换 a:转数字: 1)Number转换: 代码: var a = " ...
- Sql Server函数全解<三>数据类型转换函数和文本图像函数
阅读目录 一:数据类型转换函数 二:文本和图像函数 一:数据类型转换函数 在同时处理不同数据类型的值时,SQL Server一般会自动进行隐士类型转换.对于数据类型相近的值是有效的,比如int和flo ...
- JS 数据类型转换
JS 数据类型转换 方法主要有三种 转换函数.强制类型转换.利用js变量弱类型转换. 1. 转换函数: js提供了parseInt()和parseFloat()两个转换函数.前者把值转换成整数,后者把 ...
- 使用变量 数据类型转换 逻辑控制语句(begin ...end; case...end; if...else; while)
一:变量 变量分为局部变量和全局变量 (全局变量是系统自定的,是不可手动给值的,若想自己定义全局变量可考虑创建全局临时表!) 局部变量的定义: declare @变量名 数据类型 (局部变量只能 ...
- Util应用程序框架公共操作类(三):数据类型转换公共操作类（扩展篇）
上一篇以TDD方式介绍了数据类型转换公共操作类的开发,并提供了单元测试和实现代码,本文将演示通过扩展方法来增强公共操作类,以便调用时更加简化. 下面以字符串转换为List<Guid>为例进 ...
- Util应用程序框架公共操作类(二):数据类型转换公共操作类（源码篇）
上一篇介绍了数据类型转换的一些情况,可以看出,如果不进行封装,有可能导致比较混乱的代码.本文通过TDD方式把数据类型转换公共操作类开发出来,并提供源码下载. 我们在 应用程序框架实战十一:创建VS解决 ...
- Util应用程序框架公共操作类（一）:数据类型转换公共操作类（介绍篇）
本系列文章将介绍一些对初学者有帮助的辅助类,这些辅助类本身并没有什么稀奇之处,如何能发现需要封装它们可能更加重要,所谓授之以鱼不如授之以渔,掌握封装公共操作类的技巧才是关键,我会详细说明创建这些类的动 ...
- Sql Server函数全解(三)数据类型转换函数和文本图像函数
一:数据类型转换函数 在同时处理不同数据类型的值时,SQL Server一般会自动进行隐士类型转换.对于数据类型相近的值是有效的,比如int和float,但是对于其它数据类型,例如整型和字符类型,隐士 ...
随机推荐
- 前端经典面试题：如何理解 HTML 语义化？
本文最初于 2018-09-21 发布于 知乎 ,后在 <重学前端> 专栏的学习中,重新复习整理,发布于 Github 上,并计划写一系列前端学习相关的文章.欢迎 star . HTML ...
- 《The C Programming Language》读书笔记（一）
1. 对这本书的印象 2011年进入大学本科,C语言入门书籍如果我没记错的话应该是谭浩强的<C程序设计>,而用现在的眼光来看,这本书只能算是一本可用的教材,并不能说是一本好书.在自学操作系 ...
- 【翻译】R 中的设计模式
目录 R 中的设计模式 不动点算法 包装器模式 接口模式 柯里化(Currying) 闭包(Closures) 缓存模式 计数器模式 R 中的设计模式 本文翻译自 Design Patterns in ...
- 20155325 2017-2018 1 课上测试、课下作业、实验——码云&博客链接汇总 《信息安全系统设计基础》
第二周-课上 码云 https://gitee.com/bestiisjava2017/XinXiAnQuanXiTongSheJiJiChu20155325thl/tree/master/0927 ...
- 14-[mysql内置功能]--视图，触发器，存储过程，事务
1.视图 (1)准备数据 /* 数据导入: Navicat Premium Data Transfer Source Server : localhost Source Server Type : M ...
- [SCOI2010]传送带 三分法
[SCOI2010]传送带 LG传送门 三分法模板. 关于为什么可以三分,我选择感性理解,有人证明了,总之我是懒得证了. 假设路径是\(A \to E \to F \to D\),\(E\)和\(F\ ...
- ATmega8仿真——LED 数码管的学习
1. I/O 口的结构及特点 Atmega8 有23 个I/O 引脚,分成3 个8 位的端口B.C 和D,其中C 口只有7 位 Atmega8 采用3个8位寄存器来控制I/O端口,它们分别是:方向寄存 ...
- 腾讯x5webview集成实战
应用中许多网页由于优化的不够理想,出现加载慢,加载时间长等,而且因为碎片化导致兼容性问题,有一些网页有视频内容,产品还提出各种小窗需求,搞得心力憔悴.找到公开的有crosswalk和x5webview ...
- k8s常用命令记录
目录 kubectl常用命令 kubectl get pod -n dev 查看日志 查看pod详情 删除pod 删除job 进入pod里面 查看namespace 创建namespace 删除nam ...
- jmeter控制器（二）
循环控制器: 顾名思义就是做循环控制的,与线程组的循环一样的,不过这里的循环控制器是用在一个单独的模块的,而在线程组里面的循环是作用于全局的.循环控制器里面设置的循环次数是局部有效,只控制自己范围内的 ...