Pourquoi le manque de covariance tableau/tranche de Go nécessite-t-il des solutions de contournement pour gérer différents types de collections ?

Résoudre le manque de covariance tableau/tranche dans Go

Dans Go, l'absence de covariance tableau ou tranche peut poser des problèmes lorsque l'on travaille avec collections de différents types. Considérons le scénario suivant :

func printItems(header string, items []interface{}, fmtString string) {
  // ...
}

func main() {
  var iarr = []int{1, 2, 3}
  var farr = []float{1.0, 2.0, 3.0}
  printItems("Integer array:", iarr, "")
  printItems("Float array:", farr, "")
}

Le manque de génériques dans Go nous empêche de définir une fonction printItems générique qui accepte les collections de tout type. Au lieu de cela, nous rencontrons l'erreur suivante :

prog.go:26: cannot use iarr (type []int) as type []interface { } in function argument      
prog.go:27: cannot use farr (type []float) as type []interface { } in function argument

Solution basée sur une interface

Une approche courante pour surmonter cette limitation consiste à utiliser une interface qui définit le comportement requis. pour notre collection. Dans ce cas, nous définissons une interface List avec deux méthodes, At (pour récupérer un élément à un index spécifique) et Len (pour obtenir la longueur de la liste) :

type List interface {
    At(i int) interface{}
    Len() int
}

Nous créons ensuite des implémentations concrètes de cette interface pour nos listes entières et flottantes :

type IntList []int
type FloatList []float64

func (il IntList)   At(i int) interface{} { return il[i] }
func (fl FloatList) At(i int) interface{} { return fl[i] }

func (il IntList)   Len() int { return len(il) }
func (fl FloatList) Len() int { return len(fl) }

Avec ces implémentations en place, nous pouvons maintenant modifier notre fonction printItems pour accepter une liste comme argument, nous permettant d'imprimer les deux tableaux entiers et flottants :

import "fmt"

func printItems(header string, items List) {
    for i := 0; i < items.Len(); i++ {
        fmt.Print(items.At(i), " ")
    }
    fmt.Println()
}

Dans notre fonction principale, nous pouvons ensuite appeler printItems avec nos listes entières et flottantes, obtenant ainsi le résultat souhaité :

func main() {
    var iarr = []int{1, 2, 3}
    var farr = []float64{1.0, 2.0, 3.0}
    printItems("Integer array:", IntList(iarr))
    printItems("Float array:", FloatList(farr))
}

En utilisant une interface pour En définissant un ensemble commun d'opérations pour nos collections, nous pouvons atteindre un certain degré de flexibilité et de réutilisabilité du code, malgré l'absence de génériques dans Go.

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!