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 \n", s1, s1)
    fmt.Printf("s2: %v, type_s2: %T \n", 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 \n", s1, s1)
    fmt.Printf("s2: %v, type_s2: %T \n", 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 \n", 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 \n", 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 \n", bytea, bytea) // bytea: 98, type_bytea: int32
    ret1 := string(bytea)
    fmt.Printf("ret1: %v, type_ret1: %T \n", ret1, ret1) // ret1: 6, type_ret1: string

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

    // int64 -> string 16進制
    strHex := strconv.FormatInt(int64(97), 16)
    fmt.Printf("strHex: %v, type_strHex: %T \n", 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
}

～～～