Le package de réflexion de Go peut-il permettre des contrôles génériques de présence d'éléments dans les tranches ?

Un code générique peut-il être implémenté pour déterminer la présence d'un élément dans les tranches Go ?

Dans Go, déterminer si une tranche contient un élément spécifique est un opération courante. Cependant, pour chaque nouveau type de tranche, la mise en œuvre de cette logique peut sembler fastidieuse.

Une solution tentée consiste à utiliser une tranche d'interface{}, comme le montre l'extrait de code :

<code class="go">func sliceContains(slice []interface{}, elem interface{}) bool {
    for _, item := range slice {
       if item == elem {
          return true
       }
    }
    return false
}</code>

Cependant, cette approche est entravée par la nature de l'interface{} et la nécessité de l'implémenter pour chaque nouveau type de tranche.

Heureusement, le package de réflexion de Go fournit une solution générique :

<code class="go">func Contains(slice, elem interface{}) bool {

    sv := reflect.ValueOf(slice)

    // Check slice type.
    if sv.Kind() != reflect.Slice && sv.Kind() != reflect.Array {
        return false
    }

    // Iterate slice and compare elements.
    for i := 0; i < sv.Len(); i++ {
        if elem == sv.Index(i).Interface() {
            return true
        }
    }

    // Element not found.
    return false
}</code>

Cette fonction prend deux paramètres : la tranche et l'élément à rechercher. Il utilise la réflexion pour déterminer si la tranche est une tranche ou un tableau, puis parcourt ses éléments à l'aide des méthodes ValueOf() et Index().

Bien que cette approche générique soit pratique, elle se fait au détriment de performance. Les benchmarks montrent qu'il peut être 50 à 60 fois plus lent que les versions non génériques, comme indiqué ci-dessous :

<code class="go">func ContainsNonGeneic(slice []int, elem int) bool {
    for _, i := range slice {
        if i == elem {
            return true
        }
    }
    return false
}</code>

Résultats du benchmark :

• Générique : N=100000, 73.023214ms, 730.23214 ns/op
• Non générique : N=100000, 1.315262ms, 13.15262 ns/op

Par conséquent, alors que la fonction générique Contains() offre de la polyvalence, il doit être utilisé judicieusement pour éviter les goulots d'étranglement en termes de performances.

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!