数据类型转换

Go语言是强类型, 如果需要对数据进行类型转换，需要手动进行, 转换数据类型的简单方法是 直接通过类型()方式:

  1. valueOfTypeB = typeB(valueOfTypeA)

例如:

  1. a := 3.14
  2. b := int(a)

我们可以通过： 标准库 reflect包中的TypeOf方法查看一个变量的类型, 比如:

  1. a := 10
  2. b := 0.1314
  3. c := "hello"
  5. fmt.Printf("a type: %v\n", reflect.TypeOf(a))
  6. fmt.Printf("b type: %v\n", reflect.TypeOf(b))
  7. fmt.Printf("c type: %v\n", reflect.TypeOf(c))

自定义类型转换

Go允许我们通过type定义自己的类型,自己定义的类型和该类型不是同一类型了，比如:

  1. type Age int
  2. var a Age = 10
  3. var b int = 20
  4. fmt.Println(reflect.TypeOf(a))  // day2.Age
  5. fmt.Println(reflect.TypeOf(b))  // int

此时我们定义的Age类型已经不再是int类型了, 只是该类型底层的值为int

  1. // Age 底层数据结构为 int
  2. type Age int
  3. // a 类型是Age 底层为 int 10
  4. var a Age = 10
  6. // 将a转化成int类型,
  7. // 由于a是Age, 转化成int后, 他们不是同一种类型，不能再次赋值回去: a = int(a) 是不行的
  8. b := int(a)
  9. // 现在b是int类型
  10. fmt.Println(reflect.TypeOf(b))
  12. // 反过来我们也可以将int类型转换为Age类型
  13. c := Age(10)
  14. // 现在c就是Age类型，而不是int类型了
  15. fmt.Println(reflect.TypeOf(c))

直接转换

对于数值类 的类型 比如 int类 uint类 float类 他们直接是可以相互转换的

  1. var a float64 = 5.3232223232323
  2. fmt.Println(float32(a))
  3. fmt.Println(int(a))
  4. fmt.Println(int8(a))
  5. fmt.Println(int16(a))
  6. fmt.Println(int32(a))
  7. fmt.Println(int64(a))
  8. fmt.Println(uint(a))

1.精度损失问题
低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int

2.跨大类型转换无法转换
不是所有数据类型都能转换的，例如字母格式的string类型”abcd”转换为int肯定会失败

  1. var a float64 = 5.3232223232323
  2. fmt.Println(string(a)) // 这种会报错

如果我们想要跨大类型转换可以使用strconv包提供的函数

strconv

strconv包提供了字符串与简单数据类型之间的类型转换功能，可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型

string和int转换

  1. int转string的方法是: Itoa()
  1. str := strconv.Itoa(100)
  2. fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

2.string转int的方法是:

  1. i, err := strconv.Atoi("100")
  2. fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

并不是所有string都能转化为int, 所以可能会报错:

  1. i, err := strconv.Atoi("100x")
  2. fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()
由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

1.转bool

  1. b, err := strconv.ParseBool("true")
  2. fmt.Println(b, err)

2.转float

  1. f1, err := strconv.ParseFloat("3.1", 32)
  2. fmt.Println(f1, err)
  3. f2, err := strconv.ParseFloat("3.1", 64)
  4. fmt.Println(f2, err)

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

  1. var n float64 = 0
  2. for i := 0; i < 1000; i++ {
  3.     n += .01
  4. }
  5. fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗，你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

  • 对于整数部分 5 ，我们使用”不断除以2取余数”的方法，得到 101
  • 对于小数部分 .25 ，我们使用”不断乘以2取整数”的方法，得到 .01

听说有一个包可以解决这个问题: github.com/shopspring/decimal

3.转int

  1. func ParseInt(s string, base int, bitSize int) (i int64, err error)
  • base: 进制，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析
  • bitSize: 多少位，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8
  1. fmt.Println(bInt8(-1)) // 0000 0001(原码) -> 1111 1110(反码) -> 1111 1111
  3. // Parse 二进制字符串
  4. i, err := strconv.ParseInt("11111111", 2, 16)
  5. fmt.Println(i, err)
  6. // Parse 十进制字符串
  7. i, err = strconv.ParseInt("255", 10, 16)
  8. fmt.Println(i, err)
  9. // Parse 十六进制字符串
  10. i, err = strconv.ParseInt("4E2D", 16, 16)
  11. fmt.Println(i, err)

4.转uint

  1. func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

  1. u, err := strconv.ParseUint("11111111", 2, 16)
  2. fmt.Println(u, err)
  3. u, err = strconv.ParseUint("255", 10, 16)
  4. fmt.Println(u, err)
  5. u, err = strconv.ParseUint("4E2D", 16, 16)
  6. fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

  1. fmt.Println(strconv.FormatBool(true))
  3. // 问题又来了
  4. fmt.Println(strconv.FormatInt(255, 2))
  5. fmt.Println(strconv.FormatInt(255, 10))
  6. fmt.Println(strconv.FormatInt(255, 16))
  8. fmt.Println(strconv.FormatUint(255, 2))
  9. fmt.Println(strconv.FormatUint(255, 10))
  10. fmt.Println(strconv.FormatUint(255, 16))
  12. fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))
  1. func FormatFloat(f float64, fmt byte, prec, bitSize int) string
  • bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
  • fmt表示格式：’f’（-ddd.dddd）、’b’（-ddddp±ddd，指数为二进制）、’e’（-d.dddde±dd，十进制指数）、’E’（-d.ddddE±dd，十进制指数）、’g’（指数很大时用’e’格式，否则’f’格式）、’G’（指数很大时用’E’格式，否则’f’格式）。
  • prec控制精度（排除指数部分）：对’f’、’e’、’E’，它表示小数点后的数字个数；对’g’、’G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。