Pourquoi ne pouvez-vous pas convertir les types de tranches ?

L'incapacité de convertir des tranches de différents types, comme l'illustre l'extrait de code fourni, est due à une conversion de type spécifique. règles décrites dans la spécification Go. Ces règles régissent le moment où une valeur non constante peut être convertie en un type spécifique.

Aucune des règles de conversion ne s'applique au cas où vous tentez de convertir une tranche de Bar en une tranche de Foo. Bien que les types sous-jacents de Foo et Bar soient identiques, les types sous-jacents de leurs tranches respectives ne le sont pas. Cela entraîne l'impossibilité d'attribuer une valeur []Foo à une variable de type []Bar.

Comprendre les types sous-jacents

Il est crucial de noter que le sous-jacent le type d’une variable n’est pas nécessairement le même que le type de la variable elle-même. Dans le cas des tranches, le type d'élément est le type sous-jacent. Ainsi, alors que Foo et Bar ont le même type sous-jacent (Foo), []Foo et []Bar n'en ont pas.

Une solution pratique

Pour résoudre ce problème , vous pouvez créer un type intermédiaire qui alias Bar comme Foo. Cette approche fonctionne car le type d'élément de la tranche reste le même. Par exemple :

type Foo struct { A int }
type Bar Foo

type Foos []Foo
type Bars Foos

func main() {
    foos := []Foo{Foo{1}, Foo{2}}
    bars := Bars(foos)

    fmt.Println(bars)
}

Sortie :

[{1} {2}]

Cette solution crée des tranches avec le même type d'élément sous-jacent, permettant la conversion entre elles.

Considérations dangereuses

Par mesure de prudence, bien qu'il soit techniquement possible de « visualiser » une tranche de Foo comme une tranche de Bar à l'aide d'opérations non sécurisées, cette approche contourne la sécurité des types. Il est recommandé d'utiliser l'approche d'alias de type décrite ci-dessus pour des raisons de sécurité et de fiabilité.