Golang 任意类型切片互转

已于 2023-09-06 13:42:53 修改
阅读量1.8k 收藏 1
点赞数 1
分类专栏： Go Utils 文章标签： golang go-huge-util
于 2020-08-06 20:30:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/K346K346/article/details/107848816
版权

文章目录

1.切片转换

日常开发我们可能需要一个类型的切片转换为另一个类型的切片。

比如 int[] 转为 []string。

import "strconv"

func IntSliceToStrSlice(s []int) []string {
	if s == nil {
		return nil
	}
	r := make([]string, len(s))
	for i, v := range s {
		r[i] = strconv.Itoa(v)
	}
	return r
}

再如 []float64 转为 []string。

func Float64SliceToStrSlice(s []float64) []string {
	if s == nil {
		return nil
	}
	r := make([]string, len(s))
	for i, v := range s {
		r[i] = strconv.FormatFloat(v, 'f', -1, 64)
	}
	return r
}

上面的两个例子，除了元素类型转换的实现不同，其他的代码都是重复的。如果为多种不同类型切片互转都实现各自的转换函数，无疑是低效繁琐的。

2.反射

实际上，利用 Golang 反射，可以为目标类型切片的转换只写一个函数。比如，可以接收任意类型切片，将其转换为 []string。

// ToStrSliceE converts an any type value to a []string with returned error.
func ToStrSliceE(a any) ([]string, error) {
	if a == nil {
		return nil, nil
	}

	switch v := i.(type) {
	case []string:
		return v, nil
	}

	// If a is a slice.
	kind := reflect.TypeOf(a).Kind()
	if kind == reflect.Slice || kind == reflect.Array {
		sl := reflect.ValueOf(a)
		s := make([]string, sl.Len())
		for i := 0; i < sl.Len(); i++ {
			v, err := ToStringE(sl.Index(i).Interface())
			if err != nil {
				return nil, err
			}
			s[i] = v
		}
		return s, nil
	}
	return nil, fmt.Errorf("unable to cast %#v of type %T to []string", a, a)
}

其中 ToStringE 是一个将任意类型转换为 string 的函数，其实现如下：


// ToStringE casts any type to a string type.
func ToStringE(i any) (string, error) {
	i = indirectToStringerOrError(i)

	switch s := i.(type) {
	case string:
		return s, nil
	case bool:
		return strconv.FormatBool(s), nil
	case int:
		return strconv.Itoa(s), nil
	case int64:
		return strconv.FormatInt(s, 10), nil
	case int32:
		return strconv.Itoa(int(s)), nil
	case int16:
		return strconv.FormatInt(int64(s), 10), nil
	case int8:
		return strconv.FormatInt(int64(s), 10), nil
	case uint:
		return strconv.FormatUint(uint64(s), 10), nil
	case uint64:
		return strconv.FormatUint(uint64(s), 10), nil
	case uint32:
		return strconv.FormatUint(uint64(s), 10), nil
	case uint16:
		return strconv.FormatUint(uint64(s), 10), nil
	case uint8:
		return strconv.FormatUint(uint64(s), 10), nil
	case float64:
		return strconv.FormatFloat(s, 'f', -1, 64), nil
	case float32:
		return strconv.FormatFloat(float64(s), 'f', -1, 32), nil
	case json.Number:
		return s.String(), nil
	case []byte:
		return string(s), nil
	case template.HTML:
		return string(s), nil
	case template.HTMLAttr:
		return string(s), nil
	case template.URL:
		return string(s), nil
	case template.JS:
		return string(s), nil
	case template.JSStr:
		return string(s), nil
	case template.CSS:
		return string(s), nil
	case template.Srcset:
		return string(s), nil
	case nil:
		return "", nil
	case fmt.Stringer:
		return s.String(), nil
	case error:
		return s.Error(), nil
	default:
		return "", fmt.Errorf("unable to cast %#v of type %T to string", i, i)
	}
}

使用反射，可以避免为不同类型转为指定类型切片书写多个相似的转换函数，一定程度上实现了泛化。但其也有不足之处。

  • 反射涉及到运行时类型的判断，有一定性能开销，性能会降低 20% 左右。
  • 如果转换为不同的目标类型切片，仍需要编写多个不同的转换函数。

3.泛型

Golang 在 1.18 中引入了泛型。利用泛型，我们可以不用针对不同的目标类型切片单独实现转换函数，真正做到一个函数，完成所有类型切片间的转换。


// ToSliceE converts any type slice or array to the specified type slice.
// An error will be returned if an error occurred.
func ToSliceE[T any](a any) ([]T, error) {
	if a == nil {
		return nil, nil
	}
	switch v := a.(type) {
	case []T:
		return v, nil
	case string:
		return ToSliceE[T](strings.Fields(v))
	}

	kind := reflect.TypeOf(a).Kind()
	switch kind {
	case reflect.Slice, reflect.Array:
		// If input is a slice or array.
		v := reflect.ValueOf(a)
		if kind == reflect.Slice && v.IsNil() {
			return nil, nil
		}
		s := make([]T, v.Len())
		for i := 0; i < v.Len(); i++ {
			val, err := ToAnyE[T](v.Index(i).Interface())
			if err != nil {
				return nil, err
			}
			s[i] = val
		}
		return s, nil
	default:
		// If input is a single value.
		v, err := ToAnyE[T](a)
		if err != nil {
			return nil, err
		}
		return []T{v}, nil
	}
}

如果不关注错误，可以忽略。

// ToSlice converts an any type slice to the specified type slice.
func ToSlice[E, T any, S ~[]E](s S) []T {
	r, _ := ToSliceE[E, T](s)
	return r
}

注意，不同类型元素之间的转换，依赖 ToAnyE 函数，其实现如下：

// ToAnyE converts one type to another and returns an error if error occurred.
func ToAnyE[T any](a any) (T, error) {
	var t T
	switch any(t).(type) {
	case bool:
		v, err := ToBoolE(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case int:
		v, err := ToIntE(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case int8:
		v, err := ToInt8E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case int16:
		v, err := ToInt16E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case int32:
		v, err := ToInt32E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case int64:
		v, err := ToInt64E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case uint:
		v, err := ToUintE(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case uint8:
		v, err := ToUint8E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case uint16:
		v, err := ToUint16E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case uint32:
		v, err := ToUint32E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case uint64:
		v, err := ToUint64E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case float32:
		v, err := ToFloat32E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case float64:
		v, err := ToFloat64E(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	case string:
		v, err := ToStringE(a)
		if err != nil {
			return t, err
		}
		t = any(v).(T)
	default:
		return t, fmt.Errorf("the type %T isn't supported", t)
	}
	return t, nil
}

将不同类型的元素转换为不同目标类型时，仍需要单独实现其转换函数，因为这里的转换逻辑是不同的。

具体类型值之间的转换函数就不贴了，详见 dablelv/cyan。

4.dablelv/cyan

为了方便大家使用，以上相关代码已开源至 Github 工具库 dablelv/cyan，大家可 import 后使用，欢迎大家 star 和 pr。

import (
	"fmt"
	"github.com/dablelv/cyan/conv"
)

func main() {
	s1 := []int{1, 2, 3}
	s2 := []float64{1.1, 1.2, 1.30}
	s3 := []string{"1", "2", "3.00"}
	fmt.Println(conv.ToSliceE[string](s1))
	fmt.Println(conv.ToSliceE[string](s2))
	fmt.Println(conv.ToSliceE[int](s3))
	// and so on...
}

运行输出：

[1 2 3] <nil>
[1.1 1.2 1.3] <nil>
[1 2 3] <nil>

参考文献

github.com/dablelv/cyan

恋喵大鲤鱼
关注
专栏目录
golang中各种类型转换
abcnull 的博客
07-23 2300
文章目录基本数据之间的转换接口转其他类型string 转切片切片转 string数组转切片切片转数组string 转数组数组转 string 基本数据之间的转换 注意数据类型的范围，因为值可能溢出 // int 转 float a := 1 var b float32 = float32(a) 接口转其他类型 // 接口转基本数据类型，其实也是类型判定的一种方式 var a interface{} = "hello world" var b string = a.(string) // 接口转切片 var
Golang中interface类型转string类型
萧末的博客
10-25 1万+
Golang中interface类型转string类型 // Strval 获取变量的字符串值 // 浮点型 3.0将会转换成字符串3, "3" // 非数值或字符类型的变量将会被转换成JSON格式字符串 func Strval(value interface{}) string { var key string if value == nil { return key } swit...
探索高效开发：go-utils 工具库全面解析
最新发布
gitblog_00225的博客
08-18 438
探索高效开发：go-utils 工具库全面解析 go-utilsgo utils go语言常用工具库项目地址:https://gitcode.com/gh_mirrors/go/go-utils 在Go语言的生态系统中，寻找一个全面且高效的工具库是每个开发者都渴望的事情。今天，我们要介绍的是一个强大的Go语言工具库——go-utils，它以其丰富的功能和简洁的设计，成为了Go开发者不可或缺的利器...
golang翻转切片
qqqweiweiqq的博客
05-30 773
i:=0 j:=len(slice)-1 for i < j{ slice[i],slice[j]=slice[j],slice[i] i=i+1 j=j-1 } return slice func rev(slice []int) []int { fmt.Println(slice) for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 { slice[i], slice[j]...
golang反转切片
笔记
06-02 3868
var arr = []int{4: 1, 5: -1} // months := [...]string{1: "January", 12: "December"} arr = rev(arr) fmt.Println(arr) } func rev(slice []int) []int { fmt.Println(slice) for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 { slice[i], slice[j] = sl.
golang 类型转换
ScumVirus
07-28 1093
仅作记录，以便以后用到时查看方便。 字符串与整形： //string to 10进制int64 i,err := strconv.ParseInt(string, 10, 64) //int64 to string fmt.Sprintf("%d",int64)//我一般用这种方式 s := strconv.FormatInt(int64,10)//查找资料后得知这种方式比较正规 //s
【golang】传递任意类型的切片
小辣抓
11-10 3446
【golang】传递任意类型的切片 前言 Golang 是一门类型严格的静态语言。看看下面的代码 type MyInt = int var bar MyInt = 2 var foo int = 1 虽然上面 foo 和 bar 的底层类型都是一样的，是 int， 但是 bar 和 foo 的类型在语言层面并不一样，因此它们不能互相赋值，这样会引起 panic。 所以这样就出现了一个问题，有...
golang 切片工具类
05-04
ChangeSliceToInterface 将任意切片类型的切片 转换为 []interface{} 类型 Contains 方法可以检查给定的切片中是否存在某个元素 ConvertSliceToMap 将结构体切片转出[]map[string]interface{} FindDiffVales ...
golang 定义一个空切片_Golang 入门 : 切片(slice)
weixin_39939993的博客
12-22 962
切片(slice)是 Golang 中一种比较特殊的数据结构，这种数据结构更便于使用和管理数据集合。切片是围绕动态数组的概念构建的，可以按需自动增长和缩小。切片的动态增长是通过内置函数 append() 来实现的，这个函数可以快速且高效地增长切片，也可以通过对切片再次切割，缩小一个切片的大小。因为切片的底层也是在连续的内存块中分配的，所以切片还能获得索引、迭代以及为垃圾回收优化的好处。本文将介绍 ...
golang数组和切片作为参数和返回值
weixin_44387482的博客
08-17 6413
golang 数组和切片作为参数和返回值 1. 数组作为参数和返回值时 1.1数组的定义 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型 var arr [10]int //定义长度为10的类型是int的数组arr arr[0] = 1 // 数组的下标从0开始 数组的赋值 var arr1 = [5]int{1,2,3,4,5} //数组的初始化的定义方式 arr2 := [5]int{1,2,3,4,5} //同上 arr3
Golang 入门 : 切片(slice)
JineD的博客
03-25 1656
参考：The Go Programming Language SpecificationGo基础系列：Go slice详解 切片(slice)是 Golang 中一种比较特殊的数据结构，这种数据结构更便于使用和管理数据集合。切片是围绕动态数组的概念构建的，可以按需自动增长和缩小。切片的动态增长是通过内置函数 append() 来实现的，这个函数可以快速且高效地增长切片，也可以通过对切片再次切割，缩小一个切片的大小。因为切片的底层也是在连续的内存块中分配的，所以切片还能获得索引、迭代以及为垃圾回收优化.
Go语言中不同类型切片之间的相互转换
weixin_33825683的博客
05-20 3238
2019独角兽企业重金招聘Python工程师标准>>> ...
Golang 切片转集合
Dablelv 的博客专栏。
12-11 987
我们都知道 Golang 没有集合（Set）类型，为何如此设计呢？因为 Golang 是一门追求简单、现代、易于使用的语言，所以不会引入不必要的特性。Set 就是一个例子，Golang 有了 Map，当 Map 中的 value 为空结构体 struct{} 时，其不就是一个集合（Set）么，所以不用再单独引入一个 Set 类型。有了集合，在某些场景下，我们可能需要完成切片到集合类型的转换。Golang 中，利用反射，我们可以将任意类型的切片或数组转换为对应类型的集合。 参考上面的函数，我们可以封装我们想要
golang将整型切片转换为字符串
cf313995的博客
11-02 1572
在python中，将list转换为str，使用str.join即可，但在golang中，strings.join要求是一个字符串类型的序列，所以可以先将序列格式化成字符串，然后替换其中的空格，再去掉收尾的[]即可。
golang切片转为字符串，字符串转切片
热门推荐
笔记
02-21 1万+
golang切片转为字符串，字符串转切片 package main import ( "fmt" "strings" ) func main() { s := []string{"1", "2", "3"} ss := fmt.Sprintf(strings.Join(s, ",")) fmt.Println(ss) slice := strings.Split(ss, ",") fmt.Println(slice) //r := gin.Default() //r.GET("/",
golang数组（切片）转字符串
谜底的博客
11-12 1416
背景：在请求第三方服务的时候，比如对方返回的是一个类似的[]map[string]interface{}之类的结构，需要for循环遍历得到其中每个map的key，并将其append到一个切片中（比如是用户id）；然后想把这些id set到redis中，存一个字符串。 PHP中可以很方便这样： 而go中没有类似的函数，第一种就是for循环处理这个切片，手动拼接成一个逗号分割的字符串； 第二种就是先jsoniter.MarshalToString一下，就可以了
GO语言数组初始化（切片）及数组类型转换实例
qq_41343545的博客
05-30 1256
这里写自定义目录标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 GO语言之旅的题目：链接https://tour.go-zh.org/moretypes/18 题目： 练习：切片 实现 Pic。它应当返回一个长度为 d
Golang字符切片转字符串
weixin_44336181的博客
08-25 2851
找了很多字符切片转字符串的帖子，结果很多都是string强转，这明显报错 然后总算找到并试成功： package main import ( "fmt" "reflect" "strings" ) func main() { str := "hello" ss := strings.Split(str,"") ss[0] = "x" fmt.Println(reflect.TypeOf(ss)) fmt.Println(ss) s := strings.Join(ss,"") fm
Golang 将切片连接成字符串
Dablelv 的博客专栏。
07-21 1048
如果想要将任意类型的切片连接成字符串，可以使用反射（reflect）包来动态处理不同类型的切片，将元素转换为字符串，并拼接成一个字符串。事实上，标准库并没有针对每种类型的切片都给出一个实现，也没有使用反射给出一个通用的实现。函数，对于其他任意类型的切片，利用 Golang 提供的反射能力，在运行时将切片元素转换为字符串并连接到一起。Join 将字符串切片的所有元素连接成一个字符串，各个元素间使用给定的字符串分隔。输出符合预期，我们通过反射，只用一个函数便可将任意类型的切片连接成字符串。
golang获取切片最后一位
08-17
通过这种方式，我们可以获取任意切片的最后一位元素。注意，如果切片为空，即长度为0，那么这种方式会导致数组越界错误。在实际使用中，我们应该先判断切片长度是否大于0，再去获取最后一位元素，以避免这种错误的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值