Comment puis-je créer un conteneur générique Go pour différents types d'exécution sans erreurs de compilation ?

Conteneur générique Go avec différents types d'exécution

Dans Go, la possibilité de créer des conteneurs génériques capables de gérer des données de tout type améliore la flexibilité du code . Cependant, spécifier le type d'un canal lors du lancement de la goroutine peut être difficile car le canal peut potentiellement contenir n'importe quel type de données.

Approche initiale :

Initialement, une tentative a été conçu pour tirer parti des génériques nouvellement introduits dans Go 1.18 avec le code suivant :

func StartController[T any](sender chan Packet[T]) {
    go runThread(sender)
}

func runThread[T any](sender chan Packet[T]) {
    fmt.Println("in thread")
    for true {
        data := <-sender
        fmt.Println(data)
    }
}

Cependant, cette approche a conduit à un erreur de compilation due à l'échec de l'instanciation du type générique Packet[T interface{}].

Utilisation correcte des génériques :

Le principe de l'utilisation des génériques est qu'un Le type paramétré doit être instancié avec un paramètre de type concret avant utilisation. Par exemple, le type générique GenericChan[T any] chan T nécessite une instanciation explicite avec un type concret :

c := make(GenericChan[int])

Solution alternative :

Au lieu d'utiliser des génériques, une solution alternative consiste à utiliser le type interface{}, qui peut représenter n'importe quel type :

c := make(chan interface{})

func StartController(sender chan interface{}) {
    go runThread(sender)
}

func runThread(sender chan interface{}) {
    fmt.Println("in thread")
    for true {
        data := <-sender
        fmt.Println(data)
    }
}

Cette approche permet au canal de recevoir des données de tout type. Cependant, des assertions de type seraient nécessaires lors du traitement des données pour déterminer le type réel.

Inconvénients de l'utilisation de l'interface{} :

Bien que l'utilisation de l'interface{} offre de la flexibilité, elle introduit également des inconvénients potentiels :

• Perte de sécurité du type : l'interface{} perd le type sécurité, conduisant potentiellement à des erreurs d'exécution.
• Logique désordonnée : L'analyse et la gestion des données deviennent plus complexes en raison de la nécessité d'assertions de type.

Conclusion :

Bien que les génériques offrent des avantages, il est essentiel de comprendre leur utilisation correcte et leurs limites. Dans le cas d'un canal capable de gérer n'importe quel type, l'utilisation de interface{} reste une solution viable, bien qu'avec quelques compromis en termes de sécurité des types et de complexité du code.

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!