Gehen tut haben ", wenn " x "in" - Konstrukt ähnlich zu Python?

Ohne Iteration über das gesamte array, wie kann ich überprüfen, ob x im array mit Gehen? Hat die Sprache ein Konstrukt ist?

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

Könnte ein dupe von stackoverflow.com/q/8307478/180100
AFAIK, gibt Es keine Kurzform für die, die in gehen. Intern, python auch iteriert über das array, gibt es keinen Weg darum herum.
BTW, ein wichtiger Hinweis hierzu ist, dass es keine Möglichkeit gibt, dies zu tun (wie Sie Fragen, für) "[w]hne Iteration über das gesamte array". Solche Schleifen explizite (oder hinter einer Funktion wie strings.Index) hilft es immer deutlicher, was der code macht. Ich habe den Eindruck, dass Sie vielleicht denken, Python in array: etwas fallen/Magie. AFAIK ist es nicht. So die Schleife explizite hilft stellen Sie den Schreiber (und allen Lesern) bewusst und berücksichtigen Sie auch andere Implementierungen (z.B. eine Karte).
Allerdings, wenn "x" im set ist in der Tat sehr schnell.
Ich glaube nicht, dass wir Fragen, für eine programmatisch schnell Ansatz, wir sind nur zu Fragen für eine präzise (und immer noch nicht habe...)

InformationsquelleAutor user1529891 | 2013-03-10

go if-statement

285

Gibt es keine built-in-operator, um es in der Go. Sie benötigen zur Iteration über das array. Sie können schreiben Sie Ihre eigene Funktion, es zu tun, wie diese:
```
func stringInSlice(a string, list []string) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}
```
Wenn Sie wollen, um in der Lage zu prüfen, die Mitgliedschaft ohne Durchlaufen der ganzen Liste, müssen Sie eine Karte statt einem array oder einer Scheibe, so wie hier:
```
visitedURL := map[string]bool {
    "http://www.google.com": true,
    "https://paypal.com": true,
}
if visitedURL[thisSite] {
    fmt.Println("Already been here.")
}
```
- gibt es eine Möglichkeit, dies zu tun, ohne angeben geben? lassen Sie s sagen, wenn ich wollen einfach nur eine Allgemeine needleInHaystack(Nadel, Heuhaufen) - Funktion ohne separate Methoden für jede einzelne Art
- Man könnte das mit den spiegeln Paket, aber es wäre ziemlich ineffizient (wahrscheinlich etwa so langsam, als ob Sie schrieb es in einer dynamischen Sprache wie Python). Andere als die, keine. Das ist es, was Menschen meinen, wenn Sie sagen, die Gehen nicht über Generika.
- Jemand stolperte über diese Antwort müssen Sie beachten, dass Sie NICHT Sortieren Karten. Großer Nachteil bei der Verwendung von go-Karten.
- Sie können nicht Sortieren Karten (Objekte) in Javascript auch. Es ist ein v8 bug, die Objekte, die Werte zurückgeben, die in alphabetisch sortierter Reihenfolge.
- Karten sind nicht sortiert in den meisten Sprachen -- das ist par für den Kurs für eine map-Datenstruktur (hashmap).
InformationsquelleAutor andybalholm
78

Andere Lösung, wenn die Liste enthält statische Werte.

z.B.: überprüfung auf einen gültigen Wert aus einer Liste Gültiger Werte:
```
func IsValidCategory(category string) bool {
    switch category {
    case
        "auto",
        "news",
        "sport",
        "music":
        return true
    }
    return false
}
```
- Ja, was ist, wenn Ihre "gültige Werte" kommen aus einer Datenbank?
- Ja, das ist ordentlich, aber nur, wenn sich diese Werte können im Vorfeld definiert werden.
- dann könnte ich die verwenden WO :meinwert IN (Unterabfrage) 🙂
- Dies ist ordentlich im Vergleich zu den top-Antwort
InformationsquelleAutor sebest
47

Dies ist Zitat aus dem Buch "Programmieren in Go: Erstellung von Anwendungen für das 21 Jahrhundert":

Mithilfe einer einfachen linearen Suche, wie dieses die einzige Möglichkeit ist, unsortiert
Daten und ist gut geeignet für kleine Scheiben (bis zu Hunderten von Gegenständen). Aber für
größere Scheiben—insbesondere wenn wir die Ausführung von suchen immer wieder—die
lineare Suche ist sehr ineffizient, im Durchschnitt die Hälfte der Elemente
verglichen werden, jedes mal.

Gehen bietet eine Art.Search () - Methode verwendet die binäre Suche
Algorithmus: Dies erfordert den Vergleich von nur log2(n) Elemente (n
ist die Anzahl der Elemente) jeder Zeit. Um dies in Perspektive, eine
lineare Suche von 1000000 Elemente erfordert 500000 Vergleiche im Durchschnitt
mit einem worst case von 1000000 Vergleiche; eine binäre Suche benötigt bei
20 Vergleiche, sogar in den schlimmsten Fall.
```
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
- Dies macht nur Sinn, wenn Sie wiederholt Recherchen. Ansonsten hast du die Komplexität n*log(n)*log(n) für das Sortieren und Binär suchen, im Vergleich zu nur n für die lineare Suche.
InformationsquelleAutor AlexTT
22

Obigen Beispiel mit sort ist in der Nähe, aber im Fall von strings verwenden Sie einfach 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
- Diese Antwort sieht aus wie eine wenig informative kopieren und einfügen der Antwort weiter unten, die passiert ist, bevor Sie diese beantworten.
- Welche Antwort beziehen Sie sich? Das ist die einzige, die ich sehen sort.SearchStrings.
- Ich habe eine 100-fache Beschleunigung auf wiederholte Suchanfragen durch eine große Scheibe.
InformationsquelleAutor Robert Weber
17

Hatte gerade ähnliche Frage und beschlossen, zu versuchen, einige der Vorschläge in diesem thread.

Habe ich zudem best-und worst-case-Szenarien von 3 Arten von Suche:
- mit einer Karte
- mit einer Liste
- mit einer switch-Anweisung
hier ist die Funktion code:
```
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
}
```
best-case-Szenarien wählen Sie das erste Element in den Listen, schlimmsten Fall diejenigen verwenden, nonexistant Wert.

hier sind die Ergebnisse:

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 gewinnt alles, der Weg, der Schlimmste Fall ist, überdurchschnittlich schneller als im besten Fall.
Maps sind die schlimmsten und in der Liste näher zu wechseln.

Also die moral der Geschichte ist:
Wenn Sie eine statische, relativ kleine Liste, switch-Anweisung ist der Weg zu gehen.
- Ich weiß nicht, ob Go optimiert, in diesem Fall, aber macht es einen Unterschied, wenn Sie bewegen Sie die Initialisierung der Liste/Karte außerhalb der test-Funktion?
- Ich bin neugierig zu sehen, wie der Vergleich von spielen mit einer sortierten Liste aus, und ob die Art wäre es Wert
InformationsquelleAutor Igor
7

Andere option ist die Verwendung einer Karte als ein set. Verwenden Sie nur die Tasten und den Wert so etwas wie eine boolean-immer true. Dann können Sie einfach überprüfen, ob die Karte enthält den Schlüssel oder nicht. Dies ist nützlich, wenn Sie das Verhalten eines Satzes, wo, wenn Sie fügen Sie einen Wert mehrfach ist es nur im set einmal.

Hier ist ein einfaches Beispiel, wo ich hinzufügen Zufallszahlen als Schlüssel zu einer Karte. Wenn die gleiche Zahl erzeugt wird, mehr als einmal, es spielt keine Rolle, es erscheinen nur in der letzten Karte einmal. Dann verwende ich eine einfache wenn-check, um zu sehen, ob ein Schlüssel in der Karte oder nicht.
```
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)
        }
    }
}
```
Hier ist er auf den Spielplatz gehen

InformationsquelleAutor nobled

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.