输入转换接口片

我很好奇为什么Go不隐式地将[]T转换为[]interface{}，而将T隐式地转换为interface{}。在这个转换中，我是否遗漏了一些重要的东西?

例子:

func foo([]interface{}) { /* do something */ }


func main() {
var a []string = []string{"hello", "world"}
foo(a)
}

go build抱怨

不能在函数参数中使用(type[]字符串)作为类型[]接口{}

如果我试图显式地做它，同样的事情:b := []interface{}(a)抱怨

不能将(类型[]字符串)转换为类型[]接口{}

所以每次我需要做这个转换(似乎出现了很多)，我一直在做这样的事情:

b = make([]interface{}, len(a), len(a))
for i := range a {
b[i] = a[i]
}

是否有更好的方法，或标准库函数来帮助这些转换?每次我想调用一个可以接受整型或字符串列表的函数时，写4行额外的代码似乎有点愚蠢。

152039 次浏览
小开

试试interface{}吧。要把它铸回切片，试试

func foo(bar interface{}) {
s := bar.([]string)
// ...
}
小开
最佳答案

在Go中，有一个通用规则语法不应该隐藏复杂/昂贵的操作. c。

将string转换为interface{}在O(1)时间内完成。将[]string转换为interface{}也是在O(1)时间内完成的，因为切片仍然是一个值。然而，将[]string转换为[]interface{}需要O(n)时间，因为片中的每个元素都必须转换为interface{}。

该规则的一个例外是转换字符串。当将string转换为[]byte或[]rune时，Go执行O(n)工作，即使转换是“语法”。

没有标准库函数可以为您进行这种转换。你最好的选择是使用你在问题中给出的代码行:

b := make([]interface{}, len(a))
for i := range a {
b[i] = a[i]
}

否则，你可以用reflect创建一个，但它会比三行选项慢。反射的例子:

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
}
小开

你忽略的是T和interface{}在内存中有不同的表示形式，所以不能简单地转换。

T类型的变量就是它在内存中的值。没有关联的类型信息(在Go中，每个变量都有一个在编译时而不是在运行时已知的单一类型)。它在内存中是这样表示的:

  • 价值

保存T类型变量的interface{}在内存中是这样表示的

  • 指向类型T的指针
  • 价值

所以回到你最初的问题:为什么go不隐式地将[]T转换为[]interface{}?

将[]T转换为[]interface{}将涉及创建一个interface {}值的新片，这是一个非平凡的操作，因为内存中的布局完全不同。

小开

下面是官方的解释: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
}

然后

a := []strings{"a", "b", "c", "d"}
sliceIFace := Strings(a).ToInterfaceSlice()
小开

我很好奇通过反射转换接口数组比在循环中进行转换慢多少，如斯蒂芬的回答所述。以下是两种方法的基准比较:

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
}
}
小开

在Go 1.18或更高版本中，使用以下函数将任意片类型转换为[]interface{}或其别名any:

func ToSliceOfAny[T any](s []T) []any {
result := make([]any, len(s))
for i, v := range s {
result[i] = v
}
return result
}

Go 1.18的泛型特性并没有消除将任意切片转换为[]any的需要。下面是一个需要转换的示例:应用程序希望使用[]string的元素作为声明为args ...any的可变查询参数来查询数据库。这个答案中的函数允许应用程序在方便的一行程序中查询数据库:

rows, err := db.Query(qs, ToSliceOfAny(stringArgs)...)
小开

虽然可以使用泛型函数将切片转换为interface{}的切片，但如果可能的话，将foo更改为泛型函数可能是最合适和最便宜的执行时间。

例如:

func foo[T any](slice []T) { /* do something */ }


func main() {
var a []string = []string{"hello", "world"}
foo(a)
}

现在根本不需要转换了。


提交答案