golang基础数据类型转换小结

平时工作中总会遇到基础数据类型之间的转换，比如将string类型的数字“3.1415926”转换成float64类型。而且在golang中不能像python那样直接使用内置函数直接强制转换，这里总结一下自己平时使用到的方法。

使用fmt.Sprintf将基础数据类型转化为字符串

非字符串的数据类型转换为字符串类型有一种十分方便的方式，就是使用内置包fmt的Sprintf方法，这里给出具体的实现测试（需要注意的是这种转换的效率并不是很高！）：

package t10

import (
    "fmt"
    "testing"
)

// bool 转 string
func TestByteToString(t *testing.T) {
    t1 := true
    f1 := false
    // 将bool类型转换俄日string类型
    s1 := fmt.Sprintf("%v", t1)
    s2 := fmt.Sprintf("%v", f1)
    fmt.Printf("s1: %v, type_s1: %T 
", s1, s1)
    fmt.Printf("s2: %v, type_s2: %T 
", s2, s2)
    /*
        s1: true, type_s1: string
        s2: false, type_s2: string
    */
}

// 数字类型 转 string
func TestNumberToString(t *testing.T) {
    n1 := 123
    n2 := 123.123
    // 数字转string
    s1 := fmt.Sprintf("%d", n1)
    s2 := fmt.Sprintf("%.3f", n2)
    fmt.Printf("s1: %v, type_s1: %T 
", s1, s1)
    fmt.Printf("s2: %v, type_s2: %T 
", s2, s2)
    /*
        s1: 123, type_s1: string
        s2: 123.123, type_s2: string
    */
}

借助内置函数strconv *** 

字符串转数字类型 *

package t10

import (
    "fmt"
    "strconv"
    "testing"
)

// 字符串转数字类型
func TestStringToNum(t *testing.T) {
    // string -> int
    if ret1, err := strconv.Atoi("99"); err == nil{
        fmt.Println(ret1 == 99)// true
    }

    // string -> int64
    i64 := int64(123)
    if ret2, err := strconv.ParseInt("123", 10, 64); err == nil{
        fmt.Println(ret2 == i64)// true
    }

    // string -> int32 注意 parseInt 始终返回的是 int64，所以还是需要 int32(n) 强转一下
    i32 := int32(666)
    if ret3, err := strconv.ParseInt("666", 10, 64); err == nil{
        ret := int32(ret3)
        fmt.Println(ret == i32) // true
    }

    // string -> float32/float64
    // https://yourbasic.org/golang/convert-string-to-float/
    f := "3.1415926"
    // 1. 转float32
    if s1, err := strconv.ParseFloat(f, 32); err == nil{
        fmt.Printf("s1: %v, type_s1: %T 
", s1, s1)
        // s1: 3.141592502593994, type_s1: float64
    }

    // 2. 转float64
    if s2, err := strconv.ParseFloat(f, 64); err == nil{
        fmt.Printf("s2: %v, type_s2: %T 
", s2, s2)
        // s2: 3.1415926, type_s2: float64
    }
}

各类型转字符串 

package t10

import (
    "fmt"
    "strconv"
    "testing"
)

// 各类型转字符串
func TestToString(t *testing.T) {
    // int -> string
    strInt := strconv.Itoa(66)
    fmt.Println(strInt == "66") // true

    // byte -> string
    // 直接转
    bytea := '6'
    fmt.Printf("bytea: %v, type_bytea: %T 
", bytea, bytea) // bytea: 98, type_bytea: int32
    ret1 := string(bytea)
    fmt.Printf("ret1: %v, type_ret1: %T 
", ret1, ret1) // ret1: 6, type_ret1: string

    // int64 -> string  10进制
    strInt64 := strconv.FormatInt(int64(99), 10)
    fmt.Printf("strInt64: %v, type_strInt64: %T 
", strInt64, strInt64) // strInt64: 99, type_strInt64: string

    // int64 -> string  16进制
    strHex := strconv.FormatInt(int64(97), 16)
    fmt.Printf("strHex: %v, type_strHex: %T 
", strHex, strHex) // strHex: 61, type_strHex: string

    // int32 -> string
    // https://stackoverflow.com/questions/39442167/convert-int32-to-string-in-golang
    // 1. fast (这里为了做对比，实际上是int64)
    res1 := strconv.FormatInt(int64(23), 10)
    b1 := res1 == "23"
    fmt.Println(b1) // true
    // 2. fast (实际上还是调用的FormatInt方法！)
    res2 := strconv.Itoa(int(23))
    fmt.Println(res2 == "23") // true
    // 3. slow
    res3 := fmt.Sprintf("%d", 23)
    fmt.Println(res3 == "23") // true

}

使用第三方库cast

go get github.com/spf13/cast

package t10

import (
    "fmt"
    "github.com/spf13/cast"
    "testing"
)

func TestCast(t *testing.T){

    // 1. 转字符串
    fmt.Println(cast.ToString("helloworld")) // helloworld
    fmt.Println(cast.ToString(66)) // "66"
    fmt.Println(cast.ToString(3.1415926)) // "3.1415926"
    fmt.Println(cast.ToString([]byte("one time"))) // "one time"

    var ret interface{} = "helloWorld"
    fmt.Println(cast.ToString(ret)) // helloWorld

    // 2. 转int
    fmt.Println(cast.ToInt(8)) // 8
    fmt.Println(cast.ToInt(8.88)) // 8
    fmt.Println(cast.ToInt("8")) // 8
    fmt.Println(cast.ToInt("8.11")) // 0
    fmt.Println(cast.ToInt(true)) // 1
    fmt.Println(cast.ToInt(false)) // 0
    fmt.Println(cast.ToInt(nil)) // 0


    var eight interface{} = 8
    fmt.Println(cast.ToInt(eight)) // 8

    // 3. 转float
    fmt.Println(cast.ToFloat64("8.21132")) // 8.21132
}

～～～