Go类型转换 实现

最新推荐文章于 2022-05-07 21:17:46 发布
最新推荐文章于 2022-05-07 21:17:46 发布
阅读量773 收藏
点赞数
分类专栏： Go语言学习 文章标签： go语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Paddy90/article/details/78220743
版权

前言

近日在查看博客的时候发现阅读量最多的是我转载的一片文章“Go语言类型转换”，看来像是go语言这种强类型的语言还是有很多人有需求要对go语言中变量进行类型转换。
在平时的工作中也用到了一些将当前时间转换的问题也一并写在了里面，希望对观看者有帮助。已经将代码上传到GitHub上，名字不太好，暂时还没有改名，各位想要使用可以直接下载或者拷贝出源码使用。
下载地址。

简介

转换代码主要包含时间的转换、byte类型转换、string类型转换、int类型转换、uint类型转换、float类型转换、bool类型转换以及interface类型转换。其中conversion.go为实现文件，conversion_test.go为测试文件测试通过可放心使用。
调用示例可参考测试用例。

转换代码

若不想下载可直接拷贝如下代码使用

import (
    "bytes"
    "encoding/binary"
    "errors"
    "fmt"
    "reflect"
    "strconv"
    "time"
)

const (
    TIME_YEAR = "20060102"
    TIME_HOUR = "150405"
    TIME_NOW  = "20060102150405"
)

func TimeNow()(to string){
    return time.Now().Format(TIME_NOW)
}

func TimeYear()(to string){
    return time.Now().Format(TIME_YEAR)
}

func TimeHour()(to string){
    return time.Now().Format(TIME_HOUR)
}

func Uint32ToBytes(from uint32) (to []byte) {
    to = make([]byte, 4)
    b_buf := new(bytes.Buffer)
    binary.Write(b_buf, binary.BigEndian, from)
    copy(to, b_buf.Bytes()[0:4])
    return
}

func BytesToUint32(from []byte) (to uint32) {
    b_buf := bytes.NewBuffer(from)
    binary.Read(b_buf, binary.BigEndian, &to)
    return
}

func StringToInt(v string) (d int, err error) {
    tmp, err := strconv.ParseInt(v, 10, 32)
    if err != nil {
        return
    }
    return int(tmp), err
}

func StringToUint(v string) (d uint, err error) {
    tmp, err := strconv.ParseUint(v, 10, 32)
    if err != nil {
        return
    }
    return uint(tmp), err
}

func StringToUint8(v string) (d uint8, err error) {
    tmp, err := strconv.ParseUint(v, 10, 8)
    if err != nil {
        return
    }
    return uint8(tmp), err
}

func StringToUint32(v string) (d uint32, err error) {
    tmp, err := strconv.ParseUint(v, 10, 32)
    if err != nil {
        return
    }
    return uint32(tmp), err
}

func StringToUint64(v string) (d uint64, err error) {
    d, err = strconv.ParseUint(v, 10, 64)
    return
}

func IntToString(from int) (to string) {
    to = strconv.FormatInt(int64(from), 10)
    return
}

func Int64ToString(from int64) (to string) {
    to = strconv.FormatInt(from, 10)
    return
}

func Uint32ToString(from uint32) (to string) {
    to = strconv.FormatInt(int64(from), 10)
    return
}

func Uint64ToString(from uint64) (to string) {
    to = strconv.FormatUint(from, 10)
    return
}

func Float64ToString(from float64) (to string) {
    to = strconv.FormatFloat(from, 'f', -1, 64)
    return
}

func StringToFloat(v string) (d float32, err error) {
    tmp, err := strconv.ParseFloat(v, 10)
    d = float32(tmp)
    return
}

func StringToFloat64(v string) (d float64, err error) {
    d, err = strconv.ParseFloat(v, 10)
    return
}

func ToString(v interface{}) string {
    return fmt.Sprintf("%v", v)
}

func ToStringSlice(v interface{}) ([]string, error) {
    switch slice := v.(type) {
    case []string:
        return slice, nil
    case []interface{}:
        r := make([]string, 0, len(slice))
        for _, item := range slice {
            r = append(r, fmt.Sprintf("%v", item))
        }
        return r, nil
    default:
        return nil, errors.New(fmt.Sprintf("cannot convert %v(%v) to []string", v, reflect.TypeOf(v)))
    }
}

func ToBool(v interface{}) (bool, error) {
    switch value := v.(type) {
    case bool:
        return value, nil
    case string:
        switch value {
        case "T","t","true", "True":
            return true, nil
        case "F","f","false", "False":
            return false, nil
        default:
            return false, errors.New("cannot convert " + value + " to bool")
        }
    case float32:
        return value != 0, nil
    case float64:
        return value != 0, nil
    case int8:
        return value != 0, nil
    case int16:
        return value != 0, nil
    case int32:
        return value != 0, nil
    case int:
        return value != 0, nil
    case int64:
        return value != 0, nil
    case uint8:
        return value != 0, nil
    case uint16:
        return value != 0, nil
    case uint32:
        return value != 0, nil
    case uint:
        return value != 0, nil
    case uint64:
        return value != 0, nil
    default:
        return false, errors.New(fmt.Sprintf("cannot convert %v(%v) to bool", v, reflect.TypeOf(v)))
    }
}

func ToUint8(v interface{}) (uint8, error) {
    i, e := ToFloat64(v)
    return uint8(i), e
}

func ToUint16(v interface{}) (uint16, error) {
    i, e := ToFloat64(v)
    return uint16(i), e
}

func ToUint(v interface{}) (uint, error) {
    i, e := ToFloat64(v)
    return uint(i), e
}

func ToUint32(v interface{}) (uint32, error) {
    i, e := ToFloat64(v)
    return uint32(i), e
}

func ToUint64(v interface{}) (uint64, error) {
    i, e := ToFloat64(v)
    return uint64(i), e
}

func ToInt8(v interface{}) (int8, error) {
    i, e := ToFloat64(v)
    return int8(i), e
}

func ToInt16(v interface{}) (int16, error) {
    i, e := ToFloat64(v)
    return int16(i), e
}

func ToInt(v interface{}) (int, error) {
    i, e := ToFloat64(v)
    return int(i), e
}

func ToInt32(v interface{}) (int32, error) {
    i, e := ToFloat64(v)
    return int32(i), e
}

func ToInt64(v interface{}) (int64, error) {
    i, e := ToFloat64(v)
    return int64(i), e
}

func ToFloat32(v interface{}) (float32, error) {
    i, e := ToFloat64(v)
    return float32(i), e
}

func ToFloat64(v interface{}) (float64, error) {
    switch value := v.(type) {
    case string:
        return StringToFloat64(v.(string))
    case float32:
        return float64(value), nil
    case float64:
        return value, nil
    case int8:
        return float64(value), nil
    case int16:
        return float64(value), nil
    case int32:
        return float64(value), nil
    case int:
        return float64(value), nil
    case int64:
        return float64(value), nil
    case uint8:
        return float64(value), nil
    case uint16:
        return float64(value), nil
    case uint32:
        return float64(value), nil
    case uint:
        return float64(value), nil
    case uint64:
        return float64(value), nil
    default:
        return 0, errors.New(fmt.Sprintf("cannot convert %v(%v) to float64", v, reflect.TypeOf(v)))
    }
}

func ToInt64Slice(v interface{}) ([]int64, error) {
    switch slice := v.(type) {
    case []int64:
        return slice, nil
    case []float64:
        r := make([]int64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToInt64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)

            }
        }
        return r, nil
    case []string:
        r := make([]int64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToInt64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    case []interface{}:
        r := make([]int64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToInt64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    default:
        return nil, errors.New(fmt.Sprintf("cannot convert %v(%v) to []int64", v, reflect.TypeOf(v)))
    }
}

func ToUint32Slice(v interface{}) ([]uint32, error) {
    switch slice := v.(type) {
    case []uint32:
        return slice, nil
    case []float64:
        r := make([]uint32, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint32(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)

            }
        }
        return r, nil
    case []string:
        r := make([]uint32, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint32(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    case []interface{}:
        r := make([]uint32, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint32(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    default:
        return nil, errors.New(fmt.Sprintf("cannot convert %v(%v) to []uint32", v, reflect.TypeOf(v)))
    }
}

func ToUint64Slice(v interface{}) ([]uint64, error) {
    switch slice := v.(type) {
    case []uint64:
        return slice, nil
    case []float64:
        r := make([]uint64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)

            }
        }
        return r, nil
    case []string:
        r := make([]uint64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    case []interface{}:
        r := make([]uint64, 0, len(slice))
        for _, item := range slice {
            if i, e := ToUint64(item); e != nil {
                return nil, e
            } else {
                r = append(r, i)
            }
        }
        return r, nil
    default:
        return nil, errors.New(fmt.Sprintf("cannot convert %v(%v) to []uint64", v, reflect.TypeOf(v)))
    }
}
90Runner
关注
专栏目录
go-convert:将值转换为另一种类型
03-17
转换 将值转换为另一种类型。 go get -u github.com/Eun/go-convert 用法 package main import ( "fmt" "github.com/Eun/go-convert" ) func main () { // convert a int to a string var s string convert . MustConvert ( 1 , & s ) fmt . Printf ( "%s \n " , s ) // convert a map into a struct type User struct { ID int Name string } var u User convert . MustConvert ( map [ string ] string { "Name" : "Joe" ,
go语言基础——类型转换，内置函数和init的导包顺序，new与make的区别，类型断言，闭包，延迟调用，异常捕获和处理(panic/recover)
General_zy的博客
01-14 1061
/将MyInt定义为int类型 type MyInt int通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。//类型定义//类型别名结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。
go convert byte to string
weixin_44602409的博客
05-01 365
引用自 https://stackoverflow.com/questions/31220421/convert-a-byte-to-a-string-in-go 需求 bytes := [4]byte{1,2,3,4} str := convert(bytes) //str == "1,2,3,4" 解答 func convert( b []byte ) string { s := make([]string,len(b)) for i := range b { s[i]
golang基本数据类型转换方式
weixin_45418323的博客
11-24 1424
golang数据类型转换 一、简单类型转换 1、对于相同底层结构类型的变量，go语言可以使用简单类型转换的方式 例如：byte转string // 字符类型 var a byte = 'y' // 转换为字符串类型 b := string(a) int转float16 // int类型 a := 3 // int转float16 b := float16(a) 2、但是跨越大类型的转换使用这类简单的转换方式是不被允许的（例如：string和int、float、bool之间的转换） 二、借用内置函数s
golang 对象转换
zhaoqi5705的专栏
01-10 2587
#golang struct转数组 //转换数组类型 func coventArray(value interface{}) []interface{} { size := reflect.ValueOf(value).Len() list := make([]interface{}, size) slice := reflect.ValueOf(value).Slice(0,
Go-一个Golang的类型转换工具
08-14
Go语言，也称为Golang，是由Google开发的一种静态类型的编程语言，它强调简洁、高效和可移植性。在Go语言中，类型系统是其强项之一，但有时处理不同类型之间的转换可能会变得复杂。针对这个问题，"Go-一个Golang的...
golang实现unicode转换为字符串string的方法
09-21
// u2s 函数用于将 Unicode 编码的字符串转换为 Go 语言中的字符串类型。 func u2s(form string) (to string, err error) { bs, err := hex.DecodeString(strings.Replace(form, `\u`, "", -1)) if err != nil { ...
Go语言string，int，int64 ,float之间类型转换方法
09-21
在Go语言中，类型转换是开发过程中非常常见且重要的操作之一。本文将详细介绍Go语言中string、int、int64以及float之间的类型转换方法，并提供实际应用中的代码示例。 ### 1. int转string #### 方法一: 使用 `...
go 语言 实现的 使用modbus 协议 通过DTU tcp 链接 采集数据.zip
01-03
在本项目中，我们关注的是使用Go语言实现的Modbus协议通过DTU（Data Transfer Unit）TCP链接进行数据采集。这个项目源码提供了一个详细的实际应用案例，让我们深入理解Go语言在工业通信中的应用。 首先，`Modbus`是...
Go-kazaam-在Golang中任意转换JSON文档的API
08-13
对于使用Golang（Go语言）进行开发的程序员来说，有效地处理JSON文档是日常工作中不可或缺的部分。而"Go-kazaam"就是这样一款专为Golang设计的工具，旨在帮助开发者更加灵活、高效地操作JSON文档。 Go-kazaam的核心...
Go语言进阶之路（四）：标准错误和异常
绕行的专栏
03-30 554
Go语言内置的error接口，自定义的类型，只要实现该接口方法即可称为标准错误类型，
Go 语言的类型转换
GitChat
04-12 767
从 PHP、Nodejs 等弱类型语言转向 Go 语言开发时最头疼的就是类型转换了，Go 语言提供了万能类型 interface，常见的基础类型 int、float64、string，还有 map、slice，还有 error 等。怎么互相转换，写 restful API 时怎么转 json...来场说走就走的 Chat。 实录提要： PHP 或 NodeJS 转 Go 有什么特别的心得？ Go...
go convert_struct_to_map && convert_map_to_struct（reflect）
新的开始...
01-15 366
下午补业务系统的单测时，发现 util 包中 ConvertStructToMap 和 ConvertMapToStruct 两个函数写的有点问题，于是简单地实现了最基本的转化功能。主要基于 golang 的 reflect 包进行相应操作。顺带撸了下 github 中两个基于 reflect 进行 map、struct 操作的开源库。 structs：https://github.com/fa...
23.Go面向对象-接口继承与转换
DevOps海洋的渔夫@专栏
08-22 231
23.Go面向对象-接口继承与转换7 接口继承与转换（了解）接口也可以实现继承://子集 typeHumanerinterface{ sayhi() } //超集 typ...
Go 两种形式的“类型转换”
祈晴小义
10-31 4057
Go 的类型转换常常让人有点迷，有两种形式的类型转换： Type(obj) ：这种形式的类型转换要求 obj 对象的类型和 Type 是等价类型，即实现了相同的方法 obj.(Type) ：这种形式用于向下转型，即接口对象转结构体对象，所以 obj 必须是一个接口对象 代码示例： package main import "fmt" type Animal interface { GetName() string } // Cat 实现 Animal 接口 type Cat struct { n
go convert string to json quick solution
weixin_55399173的博客
05-07 337
package main import ( "encoding/json" "fmt" ) func main() { s := `{"a": true, "b": 1, "c": "666"}` m := make(map[string]interface{}) json.Unmarshal([]byte(s), &m) fmt.Println(m["a"]) //true fmt.Println(m["b"]) //1 fmt.Println(m) //map
Go 类型转换与别名
脚本小子-小贝的专栏
07-06 2975
package mainimport "fmt"func main() { // Go语言中没有隐式转换，都是显式转换。格式 type(var).即类型(变量) // 但转换只能在兼容类型下才行 // 1、不兼容类型不能转换 bool <=> int var b = true fmt.Printf("b = %d\n",b) // 结果: b = %!d(bool=true) // ...
Go语言类型转换
rj2017211811的博客
05-09 714
使用过go语言的都知道go语言对于类型的控制有多么的严格，因此所有的类型都应该通过显示的转换来完成，下面就给出常见的string和其他常见类型的转换以及interface{}类型转换为其他类型，具体的底层实现可以参考strconv库中的实现。 package main import ( "fmt" "strconv" ) func main() { //string与int互转 ...
Go数据类型转化
benben的博客
09-25 3394
Go是一种强类型语言，同时也属静态类型语言。 强类型语言 强类型语言也称为强类型定义语言，是一种总是强制类型定义的语言。也就是说一旦一个变量被指定了某个数据类型，如果不经过强制转化，那么它就永远是这个数据类型了。例如下面的代码中，开始处变量str的类型是字符串，接着又赋给变量str一个int类型的值，这是不允许的。 package main import "fmt" func main() {...
go语言实现将string类型转换成byte类型
最新发布
09-25
Go语言中，你可以使用`[]byte`类型或者`bytes.NewBufferString()`函数来将字符串转换为字节切片。以下是两种常见的方法： 1. **直接转换**： 如果你想将一个简单的字符串转换为字节切片，可以使用内置的`[]byte`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值