Tipo de conversão de fatias de interfaces

Estou curioso para saber por que o Go não se converte implicitamente []Tem []interface{}quando implicitamente se converte Tem interface{}. Há algo não trivial nessa conversão que estou perdendo?

Exemplo:

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

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

go build reclama

não pode usar um (tipo [] string) como tipo [] interface {} no argumento da função

E se eu tentar explicitamente, a mesma coisa: b := []interface{}(a)reclama

não é possível converter uma (tipo [] string) para digitar [] interface {}

Então, toda vez que preciso fazer essa conversão (o que parece surgir bastante), tenho feito algo assim:

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

Existe uma maneira melhor de fazer isso, ou funções de biblioteca padrão para ajudar com essas conversões? Parece meio bobo escrever 4 linhas de código extras toda vez que eu quiser chamar uma função que pode ter uma lista de, por exemplo, ints ou strings.

No Go, existe uma regra geral de que a sintaxe não deve ocultar operações complexas / caras. A conversão de um stringpara um interface{}é feita no tempo O (1). A conversão de um []stringpara um interface{}também é feita no tempo O (1), pois uma fatia ainda é um valor. No entanto, converter a []stringem um []interface{}é tempo O (n) porque cada elemento da fatia deve ser convertido em um interface{}.

A única exceção a esta regra é a conversão de cadeias. Ao converter um stringpara e de um []byteou a []rune, Go funciona O (n), mesmo que as conversões sejam "sintaxe".

Não há função de biblioteca padrão que faça essa conversão para você. Você poderia fazer um com refletir, mas seria mais lento que a opção de três linhas.

Exemplo com reflexão:

func InterfaceSlice(slice interface{}) []interface{} {
    s := reflect.ValueOf(slice)
    if s.Kind() != reflect.Slice {
        panic("InterfaceSlice() given a non-slice type")
    }

    ret := make([]interface{}, s.Len())

    for i:=0; i<s.Len(); i++ {
        ret[i] = s.Index(i).Interface()
    }

    return ret
}

Sua melhor opção é apenas usar as linhas de código que você forneceu na sua pergunta:

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

A coisa que está faltando é que Te interface{}que detém um valor de Tter diferentes representações na memória de modo não pode ser trivialmente convertido.

Uma variável do tipo Té apenas o seu valor na memória. Não há informações de tipo associadas (no Go, cada variável possui um único tipo conhecido no tempo de compilação e não no tempo de execução). É representado na memória assim:

• valor

Uma interface{}retenção de uma variável do tipo Té representada na memória como esta

• ponteiro para digitar T
• valor

Voltando à sua pergunta original: por que ir não é convertido implicitamente []Tem []interface{}?

A conversão []Tpara []interface{}envolveria a criação de uma nova fatia de interface {}valores, que é uma operação não trivial, pois o layout da memória é completamente diferente.

Aqui está a explicação oficial: 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
}

Tente em interface{}vez disso. Para converter de volta como fatia, tente

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

Converta interface{}em qualquer tipo.

Sintaxe:

result := interface.(datatype)

Exemplo:

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

Caso precise de um código mais curto, você pode criar um novo tipo para helper

type Strings []string

func (ss Strings) ToInterfaceSlice() []interface{} {
    iface := make([]interface{}, len(ss))
    for i := range ss {
        iface[i] = ss[i]
    }
    return iface
}

então

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