我很好奇为什么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行额外的代码似乎有点愚蠢。


当前回答

在Go 1.18或更高版本中,使用以下函数将任意切片类型转换为[]接口{}或其别名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的泛型特性并没有消除将任意片转换为[]任意片的需要。下面是一个需要转换的示例:应用程序希望使用[]字符串的元素作为声明为args…any的可变查询参数来查询数据库。这个答案中的函数允许应用程序在方便的一行程序中查询数据库:

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

其他回答

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

func foo(bar interface{}) {
    s := bar.([]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()

将interface{}转换为任何类型。

语法:

result := interface.(datatype)

例子:

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

官方解释如下: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
}

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

将字符串转换为接口{}需要O(1)时间。将[]字符串转换为接口{}也在O(1)时间内完成,因为切片仍然是一个值。但是,将[]字符串转换为[]接口{}需要O(n)时间,因为片的每个元素都必须转换为接口{}。

该规则的一个例外是转换字符串。当将一个字符串转换为[]字节或[]符文时,Go会执行O(n)工作,尽管转换是“语法”。

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

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

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

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
}