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

我很好奇通过反射转换接口数组比在循环中进行转换慢多少，正如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
        }
    }

在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)...)

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

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

价值

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

T型指针 价值

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

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

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

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

语法:

result := interface.(datatype)

例子:

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