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

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

2020-06-10 03:00:42 admin 511

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

## 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一般常用数据类型转换总结

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

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

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

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

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

admin 1年前