我很好奇为什么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行额外的代码似乎有点愚蠢。
当前回答
试试interface{}吧。要把它铸回切片，试试
func foo(bar interface{}) {
s := bar.([]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
}
虽然你可以使用一个泛型函数将一个slice转换为interface{}的一个slice，但是如果可能的话，从执行时间来看，将foo转换为一个泛型函数可能是最合适和最便宜的。
例如:
func foo[T any](slice []T) { /* do something */ }
func main() {
var a []string = []string{"hello", "world"}
foo(a)
}
现在根本不需要转换了。
在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
}
如果你需要更多的短你的代码，你可以为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()
你忽略的一点是，T和保存T值的interface{}在内存中有不同的表示形式，所以不能简单地转换。
T类型的变量就是它在内存中的值。没有关联的类型信息(在Go中，每个变量都有一个在编译时而不是在运行时已知的单一类型)。它在内存中是这样表示的:
价值
保存T类型变量的接口{}在内存中是这样表示的
T型指针 价值
那么回到你最初的问题:为什么go不隐式地将[]T转换为[]interface{}?
将[]T转换为[]interface{}将涉及创建一个新的接口{}值片，这是一个重要的操作，因为内存中的布局是完全不同的。
