Go contre Python : existe-t-il une construction "if x in" en Go ?

Introduction : Pourquoi les programmeurs Python regrettent-ils "in" en Go ?

Si vous venez de Python vers Go, vous vous souvenez sûrement de cette ligne magique : if "banana" in fruits:. Courte, élégante, lisible. Puis vous ouvrez Go et vous vous demandez : "Does Go have 'if x in' construct similar to Python?" — c'est exactement ainsi que se formule la question la plus populaire sur Stack Overflow, qui a recueilli des milliers de vues.

Divulgâchage : il n'existe pas de sucre syntaxique direct comme in en Go. Mais cela ne signifie pas que le problème est insoluble ou difficile à résoudre. Au contraire, Go propose plusieurs méthodes idiomatiques pour vérifier l'appartenance, chacune efficace et élégante à sa manière.

Dans cet article, nous aborderons :

\n
• Pourquoi Go n'a pas de in et comment la philosophie du langage a influencé cela ;
\n
• Comment vérifier la présence d'un élément dans une slice (y compris avec la nouvelle fonction slices.Contains) ;
\n
• Comment fonctionne la recherche dans une map (divulgâchage : c'est la méthode la plus rapide) ;
\n
• La recherche de sous-chaîne dans une chaîne avec strings.Contains ;
\n
• Écrire notre propre fonction d'encapsulation universelle pour un style "pythonique" ;
\n
• Comparer les performances des différentes approches.
\n

Pourquoi Go ne veut-il pas de "if x in" ?

Go est un langage minimaliste. Ses créateurs (Rob Pike, Ken Thompson, Rob Griesemer) ont délibérément évité de surcharger la syntaxe. Au lieu d'ajouter le mot-clé in, ils ont proposé d'utiliser des boucles explicites et des constructions intégrées.

Ce n'est pas un défaut, mais une particularité : vous voyez toujours exactement ce qui se passe. Par exemple, pour une map, la syntaxe value, ok := myMap[key] vous donne non seulement la vérification de présence, mais aussi la valeur elle-même — c'est plus puissant qu'un simple booléen True/False.

Méthode 1 : Recherche dans une slice (classique)

Le scénario le plus courant. Supposons que vous ayez une slice de chaînes et que vous deviez vérifier si "Go" s'y trouve.

Avant la version Go 1.21, vous deviez écrire une boucle manuellement :

package main\n\nimport "fmt"\n\nfunc contains(slice []string, target string) bool {\n    for _, v := range slice {\n        if v == target {\n            return true\n        }\n    }\n    return false\n}\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if contains(languages, "Go") {\n        fmt.Println("Go trouvé !")\n    }\n}\n

Ce code est du Go idiomatique. Il est explicite, rapide et compréhensible. Pour les petites slices (jusqu'à 1000 éléments), cette recherche linéaire fonctionne parfaitement.

Méthode 1.1 : Utiliser slices.Contains (Go 1.21+)

Depuis la version Go 1.21 (sortie en août 2023), la bibliothèque standard inclut le package slices avec la fonction prête à l'emploi Contains. Désormais, votre code devient presque aussi concis qu'en Python :

package main\n\nimport (\n    "fmt"\n    "slices"\n)\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if slices.Contains(languages, "Go") {\n        fmt.Println("Go trouvé ! (via slices.Contains)")\n    }\n}\n

Important : slices.Contains est une fonction générique. Elle fonctionne avec tout type qui prend en charge l'opérateur == (chaînes, nombres, booléens, structures sans slices/maps internes).

Méthode 2 : Recherche dans une map — le roi des performances

En Python, vous utilisez in pour les dictionnaires, et c'est un temps constant O(1). En Go, c'est la même chose, mais la syntaxe est différente :

package main\n\nimport "fmt"\n\nfunc main() {\n    // Création d'une map comme set\n    fruits := map[string]bool{\n        "apple":  true,\n        "banana": true,\n        "cherry": true,\n    }\n\n    if fruits["banana"] {\n        fmt.Println("banana est présent !")\n    }\n\n    // Méthode plus correcte — avec vérification ok\n    if _, ok := fruits["orange"]; ok