我很好奇为什么Go不隐式地将[]T转换为[]interface{}，而将T隐式地转换为interface{}。在这个转换中，我是否遗漏了一些重要的东西?
例子:
func foo([]interface{}) { /* do something */ }
func main() {
var a []string = []string{"hello", "world"}
foo(a)
}
去建设投诉
不能在函数参数中使用(type[]字符串)作为类型[]接口{}
如果我尝试显式地这样做，同样的事情:b:= []interface{}(a)抱怨
不能将(类型[]字符串)转换为类型[]接口{}
所以每次我需要做这个转换(似乎出现了很多)，我一直在做这样的事情:
b = make([]interface{}, len(a), len(a))
for i := range a {
b[i] = a[i]
}
是否有更好的方法，或标准库函数来帮助这些转换?每次我想调用一个可以接受整型或字符串列表的函数时，写4行额外的代码似乎有点愚蠢。
当前回答
如果你需要更多的短你的代码，你可以为helper创建新的类型
type Strings []string
func (ss Strings) ToInterfaceSlice() []interface{} {
iface := make([]interface{}, len(ss))
for i := range ss {
iface[i] = ss[i]
}
return iface
}
then
a := []strings{"a", "b", "c", "d"}
sliceIFace := Strings(a).ToInterfaceSlice()
其他回答
官方解释如下:https://github.com/golang/go/wiki/InterfaceSlice
var dataSlice []int = foo()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
interfaceSlice[i] = d
}
将interface{}转换为任何类型。
语法:
result := interface.(datatype)
例子:
var employee interface{} = []string{"Jhon", "Arya"}
result := employee.([]string) //result type is []string.
如果你需要更多的短你的代码，你可以为helper创建新的类型
type Strings []string
func (ss Strings) ToInterfaceSlice() []interface{} {
iface := make([]interface{}, len(ss))
for i := range ss {
iface[i] = ss[i]
}
return iface
}
then
a := []strings{"a", "b", "c", "d"}
sliceIFace := Strings(a).ToInterfaceSlice()
虽然你可以使用一个泛型函数将一个slice转换为interface{}的一个slice，但是如果可能的话，从执行时间来看，将foo转换为一个泛型函数可能是最合适和最便宜的。
例如:
func foo[T any](slice []T) { /* do something */ }
func main() {
var a []string = []string{"hello", "world"}
foo(a)
}
现在根本不需要转换了。
我很好奇通过反射转换接口数组比在循环中进行转换慢多少，正如Stephen的回答所描述的那样。以下是两种方法的基准比较:
benchmark iter time/iter bytes alloc allocs
--------- ---- --------- ----------- ------
BenchmarkLoopConversion-12 2285820 522.30 ns/op 400 B/op 11 allocs/op
BenchmarkReflectionConversion-12 1780002 669.00 ns/op 584 B/op 13 allocs/op
因此，使用循环比通过反射快20%。
下面是我的测试代码，以防你想验证我做的事情是否正确:
import (
"math/rand"
"reflect"
"testing"
"time"
)
func InterfaceSlice(slice interface{}) []interface{} {
s := reflect.ValueOf(slice)
if s.Kind() != reflect.Slice {
panic("InterfaceSlice() given a non-slice type")
}
// Keep the distinction between nil and empty slice input
if s.IsNil() {
return nil
}
ret := make([]interface{}, s.Len())
for i := 0; i < s.Len(); i++ {
ret[i] = s.Index(i).Interface()
}
return ret
}
type TestStruct struct {
name string
age int
}
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
func randSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = letters[rand.Intn(len(letters))]
}
return string(b)
}
func randTestStruct(lenArray int, lenMap int) map[int][]TestStruct {
randomStructMap := make(map[int][]TestStruct, lenMap)
for i := 0; i < lenMap; i++ {
var testStructs = make([]TestStruct, 0)
for k := 0; k < lenArray; k++ {
rand.Seed(time.Now().UnixNano())
randomString := randSeq(10)
randomInt := rand.Intn(100)
testStructs = append(testStructs, TestStruct{name: randomString, age: randomInt})
}
randomStructMap[i] = testStructs
}
return randomStructMap
}
func BenchmarkLoopConversion(b *testing.B) {
var testStructMap = randTestStruct(10, 100)
b.ResetTimer()
for i := 0; i < b.N; i++ {
obj := make([]interface{}, len(testStructMap[i%100]))
for k := range testStructMap[i%100] {
obj[k] = testStructMap[i%100][k]
}
}
}
func BenchmarkReflectionConversion(b *testing.B) {
var testStructMap = randTestStruct(10, 100)
b.ResetTimer()
for i := 0; i < b.N; i++ {
obj := make([]interface{}, len(testStructMap[i%100]))
obj = InterfaceSlice(testStructMap[i%100])
_ = obj
}
}
