Escriba la conversión de segmentos de interfaces en go

Question

Tengo curiosidad por qué go no convierte implícitamente []T en []interface{} cuando implícitamente convertirá T en interface{}. ¿Hay algo no trivial acerca de esta conversión que me falta?

Ejemplo:

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

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

go build se queja

no pueden utilizar un (tipo cadena []) como interfaz tipo [] {} en el argumento de la función

Y si intento para hacerlo explícitamente, lo mismo: b := []interface{}(a) se queja

No se puede convertir un (tipo cadena []) para escribir [] interfaz {}

Así que cada vez que tengo que hacer esta conversión (que parece venir mucho), he estado haciendo algo como esto:

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

¿hay una mejor manera de hacer esto, o funciones de la biblioteca estándar para ayudar con estas conversiones? Parece una tontería escribir 4 líneas adicionales de código cada vez que quiero llamar a una función que puede tomar una lista de, p. Ints o cadenas.

Answer 1

En Go, existe una regla general que dice que la sintaxis no debe ocultar operaciones complejas/costosas. La conversión de un string a un interface{} se realiza en O (1) vez. La conversión de un []string a un interface{} también se realiza en O (1) vez, ya que un sector sigue siendo un valor. Sin embargo, la conversión de []string a []interface{} es O (n) tiempo porque cada elemento del sector debe convertirse a interface{}.

La única excepción a esta regla es la conversión de cadenas. Al convertir un string ay desde un []byte o un []rune, Go hace que O (n) funcione aunque las conversiones sean "sintaxis".

No hay una función de biblioteca estándar que realice esta conversión por usted. Podría hacer uno con reflejo, pero sería más lento que la opción de tres líneas.

Ejemplo con la reflexión:

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 
} 

Su mejor opción es sin embargo sólo para usar las líneas de código que le dio en su pregunta:

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

Answer 2

Pruebe interface{} en su lugar. Para devolverlo como una porción, intente

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

Answer 3

Lo que se echa en falta es que T y interface{} que tiene un valor de T tiene diferentes representaciones en la memoria, por lo que no se puede convertir trivialmente.

Una variable del tipo T es solo su valor en la memoria.No hay información de tipo asociada (en Go, cada variable tiene un único tipo conocido en tiempo de compilación, no en tiempo de ejecución). Se representa en la memoria de esta manera:

• valor

Un interface{} la celebración de una variable de tipo T se representa en la memoria como este puntero

• para escribir T
• valor

Volviendo a su pregunta original: ¿por qué go no convierte implícitamente []T en []interface{}?

La conversión de []T a []interface{} implicaría la creación de un nuevo segmento de valores interface {} que es una operación no trivial ya que el diseño en memoria es completamente diferente.

Answer 4

Aquí está la explicación 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 
}