Est-ce que Go a une construction «if x in» similaire à Python?

Sans itérer sur l'ensemble du tableau, comment puis-je vérifier si xdans le tableau à l'aide de Go? La langue a-t-elle une construction?

Comme Python: if "x" in array: ...

Il n'y a pas d'opérateur intégré pour le faire dans Go. Vous devez parcourir le tableau. Vous pouvez écrire votre propre fonction pour le faire, comme ceci:

func stringInSlice(a string, list []string) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}

Si vous voulez pouvoir vérifier l'appartenance sans itérer sur toute la liste, vous devez utiliser une carte au lieu d'un tableau ou d'une tranche, comme ceci:

visitedURL := map[string]bool {
    "http://www.google.com": true,
    "https://paypal.com": true,
}
if visitedURL[thisSite] {
    fmt.Println("Already been here.")
}

Une autre solution si la liste contient des valeurs statiques.

ex: vérification d'une valeur valide à partir d'une liste de valeurs valides:

func IsValidCategory(category string) bool {
    switch category {
    case
        "auto",
        "news",
        "sport",
        "music":
        return true
    }
    return false
}

Ceci est une citation tirée du livre "Programming in Go: création d'applications pour le 21e siècle":

L'utilisation d'une recherche linéaire simple comme celle-ci est la seule option pour les données non triées et convient parfaitement aux petites tranches (jusqu'à des centaines d'éléments). Mais pour les tranches plus grandes, surtout si nous effectuons des recherches à plusieurs reprises, la recherche linéaire est très inefficace, nécessitant en moyenne la moitié des éléments à comparer à chaque fois.

Go fournit une méthode sort.Search () qui utilise l'algorithme de recherche binaire: cela nécessite la comparaison de seulement log2 (n) éléments (où n est le nombre d'éléments) à chaque fois. Pour mettre cela en perspective, une recherche linéaire de 1000000 éléments nécessite 500000 comparaisons en moyenne, avec le pire des cas de 1000000 comparaisons; une recherche binaire nécessite au plus 20 comparaisons, même dans le pire des cas.

files := []string{"Test.conf", "util.go", "Makefile", "misc.go", "main.go"}
target := "Makefile"
sort.Strings(files)
i := sort.Search(len(files),
    func(i int) bool { return files[i] >= target })
if i < len(files) && files[i] == target {
    fmt.Printf("found \"%s\" at files[%d]\n", files[i], i)
}

https://play.golang.org/p/UIndYQ8FeW

L'exemple ci-dessus utilisant sort est proche, mais dans le cas de chaînes, utilisez simplement SearchString:

files := []string{"Test.conf", "util.go", "Makefile", "misc.go", "main.go"}
target := "Makefile"
sort.Strings(files)
i := sort.SearchStrings(files, target)
if i < len(files) && files[i] == target {
    fmt.Printf("found \"%s\" at files[%d]\n", files[i], i)
}

https://golang.org/pkg/sort/#SearchStrings

Juste eu une question similaire et a décidé d'essayer certaines des suggestions de ce fil.

J'ai comparé les meilleurs et les pires scénarios de 3 types de recherche:

• en utilisant une carte
• en utilisant une liste
• à l'aide d'une instruction switch

voici le code de fonction:

func belongsToMap(lookup string) bool {
list := map[string]bool{
    "900898296857": true,
    "900898302052": true,
    "900898296492": true,
    "900898296850": true,
    "900898296703": true,
    "900898296633": true,
    "900898296613": true,
    "900898296615": true,
    "900898296620": true,
    "900898296636": true,
}
if _, ok := list[lookup]; ok {
    return true
} else {
    return false
}
}


func belongsToList(lookup string) bool {
list := []string{
    "900898296857",
    "900898302052",
    "900898296492",
    "900898296850",
    "900898296703",
    "900898296633",
    "900898296613",
    "900898296615",
    "900898296620",
    "900898296636",
}
for _, val := range list {
    if val == lookup {
        return true
    }
}
return false
}

func belongsToSwitch(lookup string) bool {
switch lookup {
case
    "900898296857",
    "900898302052",
    "900898296492",
    "900898296850",
    "900898296703",
    "900898296633",
    "900898296613",
    "900898296615",
    "900898296620",
    "900898296636":
    return true
}
return false
}

les meilleurs scénarios choisissent le premier élément dans les listes, les pires cas utilisent une valeur inexistante.

Voici les résultats:

BenchmarkBelongsToMapWorstCase-4 2000000 787 ns/op BenchmarkBelongsToSwitchWorstCase-4 2000000000 0.35 ns/op BenchmarkBelongsToListWorstCase-4 100000000 14.7 ns/op BenchmarkBelongsToMapBestCase-4 2000000 683 ns/op BenchmarkBelongsToSwitchBestCase-4 100000000 10.6 ns/op BenchmarkBelongsToListBestCase-4 100000000 10.4 ns/op

Switch gagne tout le chemin, le pire des cas est incroyablement plus rapide que le meilleur des cas. Les cartes sont les pires et la liste est plus proche de changer.

Donc, la morale est la suivante: si vous avez une liste statique et raisonnablement petite, la déclaration switch est la voie à suivre.

Une autre option consiste à utiliser une carte comme un ensemble. Vous utilisez uniquement les clés et la valeur doit être quelque chose comme un booléen qui est toujours vrai. Ensuite, vous pouvez facilement vérifier si la carte contient la clé ou non. Ceci est utile si vous avez besoin du comportement d'un ensemble, où si vous ajoutez une valeur plusieurs fois, elle n'est présente qu'une seule fois dans l'ensemble.

Voici un exemple simple où j'ajoute des nombres aléatoires comme clés d'une carte. Si le même nombre est généré plus d'une fois, cela n'a pas d'importance, il n'apparaîtra qu'une seule fois dans la carte finale. Ensuite, j'utilise une simple vérification si pour voir si une clé est dans la carte ou non.

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    var MAX int = 10

    m := make(map[int]bool)

    for i := 0; i <= MAX; i++ {
        m[rand.Intn(MAX)] = true
    }

    for i := 0; i <= MAX; i++ {
        if _, ok := m[i]; ok {
            fmt.Printf("%v is in map\n", i)
        } else {
            fmt.Printf("%v is not in map\n", i)
        }
    }
}

Ici, c'est sur le terrain de jeu

C'est aussi proche que possible de la sensation naturelle de l'opérateur "in" de Python. Vous devez définir votre propre type. Ensuite, vous pouvez étendre les fonctionnalités de ce type en ajoutant une méthode comme "has" qui se comporte comme vous l'espérez.

package main

import "fmt"

type StrSlice []string

func (list StrSlice) Has(a string) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}

func main() {
    var testList = StrSlice{"The", "big", "dog", "has", "fleas"}

    if testList.Has("dog") {
        fmt.Println("Yay!")
    }
}

J'ai une bibliothèque d'utilitaires où je définis quelques éléments communs comme celui-ci pour plusieurs types de tranches, comme celles contenant des entiers ou mes propres autres structures.

Oui, cela fonctionne en temps linéaire, mais ce n'est pas le but. Le but est de demander et d'apprendre quelles constructions de langage communes Go a et n'a pas. C'est un bon exercice. Que cette réponse soit stupide ou utile dépend du lecteur.