go - 类型转换接口切片

Question

我很好奇为什么 Go 不会隐式转换为何[]T时[]interface{}隐式转换T为interface{}. 我错过了这种转换是否有一些重要的东西？

例子：

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

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

go build抱怨

不能在函数参数中使用 (type []string) 作为类型 []interface {}

如果我尝试明确地这样做，同样的事情：b := []interface{}(a)抱怨

无法将 (type []string) 转换为 type []interface {}

所以每次我需要进行这种转换（这似乎经常出现）时，我一直在做这样的事情：

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

有没有更好的方法来做到这一点，或者标准库函数来帮助这些转换？每次我想调用一个可以获取整数或字符串列表的函数时，多写 4 行代码似乎有点愚蠢。

score 288 · Accepted Answer

在 Go 中，有一条通用规则，即语法不应隐藏复杂/昂贵的操作。将 a 转换string为 aninterface{}在 O(1) 时间内完成。将 a 转换[]string为 aninterface{}也是在 O(1) 时间内完成的，因为切片仍然是一个值。但是，将 a 转换[]string为 an[]interface{}需要 O(n) 时间，因为切片的每个元素都必须转换为 an interface{}。

此规则的一个例外是转换字符串。在将 astring与 a[]byte或 a[]rune相互转换时，即使转换是“语法”，Go 也会 O(n) 工作。

没有标准库函数可以为您进行这种转换。您可以使用反射制作一个，但它会比三行选项慢。

反射示例：

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
}

不过，您最好的选择就是使用您在问题中提供的代码行：

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

score 70 · Accepted Answer

您缺少的是，T它interface{}的值T在内存中有不同的表示形式，因此不能简单地转换。

类型变量T只是它在内存中的值。没有关联的类型信息（在 Go 中，每个变量都有一个在编译时而不是在运行时已知的单一类型）。它在内存中表示如下：

价值

interface{}持有一个类型的变量在T内存中表示如下

类型指针T
价值

所以回到你原来的问题：为什么 go 不隐式转换[]T为[]interface{}？

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

score 19 · Accepted Answer

这里是官方的解释：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
}

score 6 · Accepted Answer

试试interface{}吧。要作为切片回滚，请尝试

func foo(bar interface{}) {
    s := bar.([]string)
    // ...
}

score 3 · Accepted Answer

如果您需要更多缩短代码，您可以为助手创建新类型

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()

score 2 · Accepted Answer

我很好奇通过反射转换接口数组与在循环中执行它相比要慢多少，如斯蒂芬的回答中所述。这是两种方法的基准比较：

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

score 0 · Accepted Answer

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

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

score -3 · Accepted Answer

转换interface{}成任何类型。

句法：

result := interface.(datatype)

例子：

var employee interface{} = []string{"Jhon", "Arya"}
result := employee.([]string)   //result type is []string.

go - 类型转换接口切片

8 回答 8

Related

Reference