Type de conversion de tranches d'interfaces

Je suis curieux de savoir pourquoi Go ne se convertit []Tpas implicitement en []interface{}quand il se convertira implicitement Ten interface{}. Y a-t-il quelque chose de non trivial dans cette conversion qui me manque?

Exemple:

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

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

go build Se plaint

impossible d'utiliser une chaîne (type []) comme type [] interface {} dans l'argument de la fonction

Et si j'essaye de le faire explicitement, même chose: se b := []interface{}(a)plaindre

impossible de convertir une (type [] string) en type [] interface {}

Donc, chaque fois que j'ai besoin de faire cette conversion (ce qui semble arriver souvent), j'ai fait quelque chose comme ceci:

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

Existe-t-il une meilleure façon de faire cela, ou des fonctions de bibliothèque standard pour aider à ces conversions? Cela semble un peu idiot d'écrire 4 lignes de code supplémentaires chaque fois que je veux appeler une fonction qui peut prendre une liste d'ints ou de chaînes, par exemple.

Dans Go, il existe une règle générale selon laquelle la syntaxe ne doit pas masquer les opérations complexes / coûteuses. La conversion de a stringen an interface{}se fait en temps O (1). La conversion de a []stringen an interface{}se fait également en temps O (1) car une tranche est toujours une valeur. Cependant, la conversion de a []stringen an []interface{}est un temps O (n) car chaque élément de la tranche doit être converti en un interface{}.

La seule exception à cette règle est la conversion de chaînes. Lors de la conversion de a stringvers et depuis a []byteou a []rune, Go fait O (n) fonctionne même si les conversions sont "syntaxiques".

Il n'y a pas de fonction de bibliothèque standard qui fera cette conversion pour vous. Vous pouvez en créer un avec Reflect, mais ce serait plus lent que l'option à trois lignes.

Exemple avec réflexion:

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
}

Votre meilleure option est cependant simplement d'utiliser les lignes de code que vous avez fournies dans votre question:

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

La chose qui vous manque est celle-là Tet interface{}qui détient une valeur de Tavoir différentes représentations en mémoire et ne peut donc pas être convertie de manière triviale.

Une variable de type Test juste sa valeur en mémoire. Il n'y a pas d'informations de type associées (dans Go, chaque variable a un seul type connu au moment de la compilation et non au moment de l'exécution). Il est représenté en mémoire comme ceci:

• valeur

Un interface{}tenant une variable de type Test représenté en mémoire comme ceci

• pointeur sur le type T
• valeur

Revenons donc à votre question initiale: pourquoi aller n'est-il pas implicitement converti []Ten []interface{}?

La conversion []Ten []interface{}impliquerait la création d'une nouvelle tranche de interface {}valeurs, ce qui est une opération non triviale car la disposition en mémoire est complètement différente.

Voici l'explication officielle: 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
}

Essayez à la interface{}place. Pour reconstituer une tranche, essayez

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

Convertissez interface{}en n'importe quel type.

Syntaxe:

result := interface.(datatype)

Exemple:

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

Au cas où vous auriez besoin de raccourcir plus votre code, vous pouvez créer un nouveau type pour helper

type Strings []string

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

puis

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