Golang ha costrutto "if x in" simile a Python?

Question

Senza iterazione su tutto l'array come posso controllare se 'x' in array in Vai?

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

Answer 1

Non v'è alcun built-in operatore di farlo in Go. È necessario scorrere l'array. È possibile scrivere la propria funzione per farlo, in questo modo:

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

Se si vuole essere in grado di verificare la presenza di appartenenza, senza l'iterazione su tutta la lista, è necessario utilizzare una mappa al posto di un array o slice, in questo modo:

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

Answer 2

questo è citazione dal libro "Programmazione in Go: creazione di applicazioni per il 21 ° secolo":

Utilizzando una semplice ricerca lineare come questo è l'unica opzione per indifferenziati dati un e va bene per piccole fette (fino a centinaia di articoli). Ma per le porzioni più grandi di , specialmente se eseguiamo ricerche ripetutamente, la ricerca lineare è molto inefficiente, in media richiede la metà degli articoli da confrontare ogni volta.

Go fornisce un metodo sort.Search(), che utilizza l'algoritmo di ricerca binaria : questo richiede il confronto del solo log2 (n) articoli (dove n è il numero di elementi) di volta in volta. Per mettere questo in prospettiva, una ricerca lineare di 1000000 elementi richiede 500000 confronti in media, con il caso peggiore di 1000000 confronti; una ricerca binaria necessita di la maggior parte dei 20 confronti, anche nel caso peggiore.

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

Answer 3

Un'altra soluzione, se l'elenco contiene valori statici.

esempio: controllo di un valore valido da un elenco di valori validi:

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

Answer 4

L'esempio utilizzando ordinamento è vicino, ma nel caso di stringhe sufficiente utilizzare 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

Answer 5

Un'altra opzione è l'utilizzo di una mappa come set. Usi solo le chiavi e il valore è qualcosa di simile a un booleano che è sempre vero. Quindi puoi facilmente verificare se la mappa contiene o meno la chiave. Questo è utile se hai bisogno del comportamento di un set, dove se aggiungi un valore più volte è solo nel set una volta.

Ecco un semplice esempio in cui aggiungo numeri casuali come chiavi a una mappa. Se lo stesso numero viene generato più di una volta, non importa, apparirà solo una volta nella mappa finale. Quindi uso un semplice controllo per vedere se una chiave è nella mappa o no.

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) 
     } 
    } 
} 

Here it is on the go playground