Pourquoi ne puis-je pas convertir une tranche de « Foo » en une tranche de « Bar » dans Go ?

Pourquoi Go n'autorise pas la conversion des types de tranches (par exemple []Foo en []Bar)

Introduction

En Go, l'attribution d'une valeur à une variable d'un type différent n'est généralement pas autorisée en raison de la sécurité des types et des règles de conversion. Comme vous l'avez découvert, vous ne pouvez pas convertir une tranche de structures d'un type (par exemple []Foo) en une tranche d'un type différent (par exemple []Bar). Cet article vise à clarifier pourquoi cette conversion n'est pas possible, même si les types sous-jacents de Foo et Bar peuvent être identiques.

Règles de conversion

Selon la spécification Go , une valeur non constante x peut être convertie en type T uniquement si l'un des critères suivants est rempli :

• x est attribuable à T.
• Les types sous-jacents de x et T sont identiques.
• x et T sont des types de pointeurs sans nom avec des types de base identiques.
• x et T sont tous deux des types entiers, à virgule flottante ou complexes.
• x est un entier ou une tranche d'octets/runes, et T est un type de chaîne.
• x est une chaîne et T est une tranche d'octets/runes.

Types sous-jacents de tranches

Le type sous-jacent d'une tranche est un pointeur vers le type d'élément. Par exemple, le type sous-jacent de []Foo est []Foo, et le type sous-jacent de []Bar est []Bar. Même si le type sous-jacent de Foo est le même que le type sous-jacent de Bar, cela ne se traduit pas par des types sous-jacents identiques pour les tranches de Foo et Bar.

Raison de la non-conversion

Par conséquent, la raison pour laquelle Go n'autorise pas la conversion entre des tranches de différents types d'éléments, même si les types sous-jacents sont les mêmes, est que les types sous-jacents des tranches ne sont pas identiques. Par conséquent, une conversion de type, telle que []Bar(foos), n'est pas autorisée.

Solution alternative

Une solution possible à ce problème consiste à définir un alias de type personnalisé pour une tranche de Foo, telle que Foos. Cela vous permet de créer une tranche de Bars à partir d'une tranche de Foos, comme illustré dans le code suivant :

<code class="go">type Foo struct{ A int }
type Foos []Foo
type Bars Foos

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

    fmt.Println(bars)
}</code>

Dans ce cas, les types sous-jacents de Foos et Bars sont identiques, et la conversion fonctionne comme attendu.

Considérations sur les packages non sécurisés

Bien que Go interdise généralement les opérations non sécurisées, il est possible d'utiliser le package non sécurisé pour contourner la restriction de conversion. Cependant, cela doit être fait avec prudence et en comprenant les conséquences potentielles, car cela peut compromettre la sécurité des types.

Conclusion

Comprendre les règles de conversion et les types de tranches sous-jacents est crucial pour gérer les conversions de type dans Go. Bien que la conversion directe entre des tranches de différents types d'éléments ne soit pas autorisée, il existe des solutions alternatives, telles que la définition d'alias de type personnalisés, pour obtenir la fonctionnalité souhaitée tout en maintenant la sécurité des types.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!