网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

golang一般常用数据类型转换总结

2020-06-09 19:00:42 admin 1004

在编程中经常会碰到一些数据类型转换问题，每次都要搜索查询好久，今天直接自己整理一下

## string

#### string到int (Atoi)

int ,err:=strconv.Atoi(string)

#### string到int (ParseInt)

// 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)

fmt. Println(strconv.ParseInt("123", 10, 8))

#### string到int64

int64 , err := strconv.ParseInt(string, 10, 64)

#### string到uint

// ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数  
func ParseUint(s string, base int, bitSize int) (n uint64, err error)

fmt. Println(strconv.ParseUint("FF", 16, 8))

#### string到bool

// ParseBool 将字符串转换为布尔值

// 它接受真值：1, t, T, TRUE, true, True

// 它接受假值：0, f, F, FALSE, false, False.

// 其它任何值都返回一个错误

strconv.ParseBool("1")

#### string到float

// s：要转换的字符串  
// bitSize：指定浮点类型（32:float32、64:float64）  
// 如果 s 是合法的格式，而且接近一个浮点值，  
// 则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）  
// 如果 s 不是合法的格式，则返回“语法错误”  
// 如果转换结果超出 bitSize 范围，则返回“超出范围”  
func ParseFloat(s string, bitSize int) (f float64, err error)

s := "0.12345678901234567890"
    f, err := strconv.ParseFloat(s, 32)
    fmt.Println(f, err)          // 0.12345679104328156

#### string到time

其中layout的时间必须是"2006-01-02 15:04:05"这个时间，不管格式如何，时间点一定得是这个，如："Jan 2, 2006 at
3:04pm (MST)"，"2006-Jan-02"等。如换一个时间解析出来的时间就不对了，要特别注意这一点。

layout := ""2006-01-02 15:04:05.999999""
    t, _ := time.Parse(layout, "2013-10-05 18:30:50")
    fmt.Println(t.Year())
    // 当前时区时间格式化转换
    strTime := "2018-03-24T20:01:00+08:00"
    tim, _:=time.ParseInLocation("2006-01-02T15:04:05+08:00", strTime, time.Local)

## int

#### int到string

string :=strconv.Itoa(int)

#### 将 int 型整数 i 转换为字符串形式，并追加到 dst 的尾部

// AppendInt 将 int 型整数 i 转换为字符串形式，并追加到 dst 的尾部  
// i：要转换的字符串  
// base：进位制  
// 返回追加后的 []byte  
func 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
    }

#### int64到string

// 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
    }

#### int64到time(将纳秒转time)

tt := time.Unix(0,1515049539324129700) //将纳秒转换为 time 类型
    fmt.Println(tt.String())

#### int64到time(将毫秒转time)

tt := time.Unix(0,毫秒*1e6) //将纳秒转换为 time 类型
    fmt.Println(tt.String())

#### int64到time(将秒转time)

tt := time.Unix(1136214245,0) //将秒转换为 time 类型
    fmt.Println(tt.String())

## Float

#### Float到string

// 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

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))

#### 将float转string并将结果追加到尾部

// AppendFloat 将浮点数 f 转换为字符串值，并将转换结果追加到 dst 的尾部  
// 返回追加后的 []byte  
func 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
    }

## Uint

#### Uint到string

// 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
    }

#### 将 uint 型整数 i 转换为字符串形式，并追加到 dst 的尾部

// AppendUint 将 uint 型整数 i 转换为字符串形式，并追加到 dst 的尾部  
// i：要转换的字符串  
// base：进位制  
// 返回追加后的 []byte  
func 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
    }

## bool

#### bool到string

fmt.Println(strconv.FormatBool(0< 1)) // true
    fmt.Println(strconv.FormatBool(0 > 1)) // false

#### 将bool转string并将结果追加到尾部

// AppendBool 将布尔值 b 转换为字符串 "true" 或 "false"  
// 然后将结果追加到 dst 的尾部，返回追加后的 []byte  
func 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
    }

## time

#### 获取纳秒值

na :=time.Now().UnixNano()

#### 获取毫秒值

na :=time.Now().UnixNano()//获取时间戳包含纳秒
    fmt.Println(na / 1e6) //纳秒转毫秒
    fmt.Println(na / 1e9) //纳秒转秒

#### 获取秒值

miao :=time.Now().Unix()

#### 时间转string

time. Now().Format("2006-01-02 15:04")

#### 年月日时分秒转time

the_time := time.Date(2014, 1, 7, 5, 50, 4, 0, time.Local)
    unix_time := the_time.Unix()
    fmt.Println(unix_time)

## interface

#### 与基本类型转换

func main() {
        //var i interface{} = "TT"
        var i interface{} = 77
        value, ok := i.(int)
        if ok {
            fmt.Printf("类型匹配int:%d\n", value)
        } else {
            fmt.Println("类型不匹配int\n")
        }
        if value, ok := i.(int); ok {
            fmt.Println("类型匹配整型：%d\n", value)
        } else if value, ok := i.(string); ok {
            fmt.Printf("类型匹配字符串:%s\n", value)
        }
    }

#### 断言的使用

func echoArray(a interface{}){
        b,_:=a.([]int)//通过断言实现类型转换
        for _,v:=range b{
            fmt.Print(v," ")
            }
        fmt.Println()
        return
    }

转载文章，原文链接： golang一般常用数据类型转换总结

关键字词golang 类型转换

分享到：

上一篇：go Socket编程

下一篇：排序问题总结

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

golang一般常用数据类型转换总结

zhou 4年前

zhou 4年前

zhou 4年前

zhou 4年前

武云 4年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

golang一般常用数据类型转换总结

zhou 4年前

zhou 4年前

zhou 4年前

zhou 4年前

武云 4年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。