go语言数据类型转换

go语言中数据类型转换基本是通过数据类型函数、strconv库、断言这三种方式来实现.

一、通过数据类型函数转换

这种形式与其他语言的强制类型转换有些类似,如(int)这种形式.但是它有很多的局限性,它目前只支持数字与字符串之间的转换.(因此,在日常开发中比较少用)

1、其他类型转成字符串
  • 整型转字符串

转换规则:得到的字符串即为数字对应的UTF8编码值.

  1. var num int = 65
  2. var numStr string = string(num)
  3. fmt.Println(numStr) //对应的结果是整型对应的utf8码值,如65对应大写字母A
  4. var maxNum int64 = 500
  5. fmt.Println(string(maxNum)) //输出:Ǵ(注意不是G)
  6. var n byte = 5 //因为byte其实是uint8的别名
  7. fmt.Println(string(n))
  8. var r rune = 70 //因为rune其实是int32的别名
  9. fmt.Println(string(r))
2、其他类型转整型

目前只支持浮点型转整数

  1. var price float32 = 5.99
  2. fmt.Println(int32(price)) //结果为5
3、其他类型转浮点型

目前只支整型转浮点型

  1. fmt.Println(float32(100)) //结果为100
二、通过strconv库函数转换

strconv库的作用主要是字符串与其他数据类型相互转换的函数

  • ParseXXX:将字符串转换为XXX类型(XXX有int,uint,bool,float这几种)
  • FormatXXX:将XXX类型转换为字符串
1、字符串与整型数据之间的转换
  • (1)字符串转化为整数

通过strconv.Atoi转换

  1. i, err := strconv.Atoi("98")
  2. if err != nil {
  3. fmt.Println(err)
  4. } else {
  5. fmt.Println(i)
  6. }

通过strconv.ParseInt来转换

  1. resultNum, err := strconv.ParseInt("100", 10, 64)
  2. if err != nil {
  3. fmt.Println(err)
  4. } else {
  5. fmt.Println(resultNum)
  6. }
  • (2)整数转化为字符串

通过strconv.Itoa来转换

Itoa的本质也是调用FormatInt函数

  1. s := strconv.Itoa(4)
  2. fmt.Println(s)

通过FormatInt来转换

  1. str2 := strconv.FormatInt(5, 10)
  2. fmt.Println(str2)
2、字符串与浮点数据之间的转换
  • (1)字符串转化为浮点型
  1. f, err := strconv.ParseFloat("0.9", 64)
  2. if err != nil {
  3. fmt.Println(err)
  4. } else {
  5. fmt.Println(f)
  6. }
  • (2)浮点数转化为字符串 strconv.FormatFloat
    • 第一个参数要转换的数字
    • 第二个参数是格式,f表示浮点数表示;g表示原样输出
    • 第三个参数是保留的小数点位数
    • 第四上是以多少位的浮点型返回(如32表示flat32,64表示float64)
  1. fmt.Println(strconv.FormatFloat(6.999, 'f', 4, 64))
3、字符串与布尔bool数据之间的转换
  • (1)字符串转化为布尔型数据
  1. b, err := strconv.ParseBool("FALSE")
  2. if err != nil {
  3. fmt.Println(b)
  4. } else {
  5. fmt.Println(b)
  6. }

字符串转换为bool类型的介绍:

原字符串(字符串) 转换为的值(布尔类型) 其他说明
1 true
0 false
true true
True true
TRUE true
false false
False false
FALSE false
除上述之外的字符串 false 会抛出错误
  • (2)浮点数转化为字符串
  1. fmt.Println(strconv.FormatBool(true)) //字符串true
  2. fmt.Println(strconv.FormatBool(false)) //字符串false
三、通过断言来转换类型

注:这种方法一般用来把interface类型转化为具体的数据类型(因为其他所有数据类型都实现了空接口类型interface{})

1、基本用法
  1. value, ok := var.(Type)
  • value 即为转换后的值
  • ok 判断是否转换成功(是一个布尔值)
  • var 表示要转换的变量 
  • Type为要转换的具体的数据类型
2、实例说明
  • 如配置文件的配置项,其结构如下:
    • 键名为字符串
    • 键值是一个空接口(因为每个配置项的值可能数据类型不一致)
  1. type ConfigItem struct {
  2. key string
  3. value interface{}
  4. }
  • 当配置项的值是整数时:
  1. var maxItems ConfigItem = ConfigItem{
  2. key : "maxItems",
  3. value : 100,
  4. }
  5. maxItemsValue, ok := maxItems.value.(int)
  6. if ok {
  7. fmt.Println(maxItemsValue)
  8. } else {
  9. fmt.Println("get maxItems failed")
  10. }
  • 当配置项的值为字符串时
  1. var logo ConfigItem = ConfigItem{
  2. key : "logo",
  3. value : "https://static.shixinke.com/resources/images/logo.png",
  4. }
  5. logoValue, ok := logo.value.(string)
  6. if ok {
  7. fmt.Println(logoValue)
  8. } else {
  9. fmt.Println("get logo failed")
  10. }
四、其他类型的转换
1、json字符串与映射之间的转换

json的操作需要用到encoding/json这个库

  • (1)json字符串转换为映射
  1. var configJson = `{"site_name":"诗心", "domain":"shixinke.com"}`
  2. var configMap map[string]string
  3. json.Unmarshal([]byte(configJson), &configMap)
  4. fmt.Println(configMap) //输出:map[site_name:诗心 domain:shixinke.com]
  • (2)映射转换为json字符串
  1. var cityMap map[string]string = map[string]string{
  2. "hz":"杭州",
  3. "nj":"南京",
  4. "sh":"上海",
  5. }
  6. cityMapBytes, err := json.Marshal(cityMap)
  7. var cityMapStr string
  8. var cityCopyMap map[string]string
  9. if err != nil {
  10. fmt.Println(err)
  11. } else {
  12. cityMapStr = string(cityMapBytes)
  13. fmt.Println(cityMapStr) //输出:{"hz":"杭州","nj":"南京","sh":"上海"}
  14. }
  15. json.Unmarshal(cityMapBytes, &cityCopyMap)
  16. fmt.Println(cityCopyMap) //输出:map[nj:南京 sh:上海 hz:杭州]
2、json字符串与结构体之间的转换
  • (1)json字符串转换为结构体
  1. var configJson = `{"site_name":"诗心", "domain":"shixinke.com"}`
  2. var configMap map[string]string
  3. json.Unmarshal([]byte(configJson), &configMap)
  4. fmt.Println(configMap) //输出:map[site_name:诗心 domain:shixinke.com]
  • (2)结构体转换为json字符串

注:当结体体要与json相互转换时,可以在结构体定义时指定json对象的键名(在结构体成员变量名与json对象键名不致的情况下,默认是不用指定的);结构体与json相互转换时,结构体的成员变量必须是公开的(即变量名首字母大写),不是私有的

A 、结构体转换为json字符串

普通结构体定义:

  1. type SiteConfig struct {
  2. SiteName string
  3. Domain string
  4. }

与json相互转换:

  1. siteConfigObj = SiteConfig{
  2. "诗心博客",
  3. "shixinke.com"}
  4. configStr, err := json.Marshal(siteConfigObj)
  5. if err != nil {
  6. fmt.Println(err)
  7. } else {
  8. fmt.Printf("%s\n", configStr)
  9. }

输出结果:

  1. {"SiteName":"诗心博客","Domain":"shixinke.com"}

与json转换结构体

  1. type SiteConfigStruct struct {
  2. SiteName string `json:"siteName"`
  3. Domain string `json:"domain"`
  4. }

格式说明:

  • 除了与普通结构体一样有成员外,后面还可以跟一个指定json键的字符串,格式为:json:"keyName"(keyName为当前成员对应的json对象的键名,可以与成员变量名相同,也可以不同)

B 、json字符串转换为结构体

  1. jsonStr := `{"siteName":"诗心博客","domain":"shixinke.com"}`
  2. var jsonObj SiteConfigStruct
  3. json.Unmarshal([]byte(jsonStr), &jsonObj)
  4. fmt.Println(jsonObj)