Go'nun Python'a benzer bir “if x in” yapısı var mı?

Olmadan tüm dizi boyunca yineleme, nasıl kontrol edebilirsiniz xGit kullanarak dizide? Dilin bir yapısı var mı?

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

Go'da yapacak yerleşik bir operatör yoktur. Dizi üzerinde yineleme yapmanız gerekir. Bunu yapmak için kendi işlevinizi yazabilirsiniz, şöyle:

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

Tüm listeyi yinelemeden üyeliği kontrol etmek istiyorsanız, aşağıdaki gibi bir dizi veya dilim yerine bir harita kullanmanız gerekir:

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

Liste statik değerler içeriyorsa başka bir çözüm.

örneğin: geçerli değerler listesinden geçerli bir değerin kontrol edilmesi:

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

"Go to Programming: 21. Yüzyıl İçin Uygulama Yaratmak" kitabından alıntı:

Bu şekilde basit bir doğrusal arama kullanmak, sıralanmamış veriler için tek seçenektir ve küçük dilimler için (yüzlerce öğeye kadar) uygundur. Ancak daha büyük dilimler için - özellikle de tekrar tekrar arama yapıyorsak - doğrusal arama çok verimsizdir, ortalama olarak her seferinde öğelerin yarısının karşılaştırılmasını gerektirir.

Go, ikili arama algoritmasını kullanan bir sort.Search () yöntemi sağlar: Bu, her seferinde yalnızca log2 (n) öğelerinin (burada n öğe sayısıdır) karşılaştırılmasını gerektirir. Bunu perspektife sokmak için, 1000000 öğenin doğrusal bir araştırması, en kötü 1000000 karşılaştırması ile ortalama 500000 karşılaştırmayı gerektirir; bir ikili arama en kötü durumda bile en fazla 20 karşılaştırmaya ihtiyaç duyar.

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

Sıralama kullanan yukarıdaki örnek yakındır, ancak dizeler için SearchString kullanın:

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

Sadece benzer bir sorum vardı ve bu konudaki bazı önerileri denemeye karar verdim.

3 tür arama için en iyi ve en kötü senaryoları karşılaştırdım:

• bir harita kullanmak
• bir liste kullanmak
• switch deyimi kullanma

İşte fonksiyon kodu:

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
}

en iyi durum senaryoları listelerdeki ilk öğeyi seçer, en kötü durum olanlar var olmayan değeri kullanır.

sonuçlar burada:

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

Anahtar tamamen kazanır, en kötü durum en iyi durumdan çok daha hızlıdır. Haritalar en kötüsüdür ve liste geçişe daha yakındır.

Ahlaki şudur: Statik, oldukça küçük bir listeniz varsa, switch deyimi gitmenin yoludur.

Başka bir seçenek de haritayı küme olarak kullanmaktır. Sadece anahtarları kullanırsınız ve değerin her zaman doğru olan bir boolean gibi olması gerekir. Ardından haritanın anahtarı içerip içermediğini kolayca kontrol edebilirsiniz. Bu, bir kümenin davranışına ihtiyacınız varsa kullanışlıdır; burada bir değeri birden çok kez eklerseniz, bu değer yalnızca kümede bir kez olur.

İşte bir haritaya anahtar olarak rastgele sayılar eklediğim basit bir örnek. Aynı sayı farketmeden bir kereden fazla üretilirse, son haritada yalnızca bir kez görünür. Sonra bir anahtarın harita üzerinde olup olmadığını görmek için basit bir kontrol kullanıyorum.

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

İşte hareket halindeyken oyun alanı

Bu, Python'un "inç" operatörünün doğal hissine ulaşabileceğim kadar yakın. Kendi tipinizi tanımlamanız gerekir. Daha sonra "has" gibi bir yöntem ekleyerek umduğunuz gibi davranarak bu türün işlevselliğini genişletebilirsiniz.

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

Tamsayı veya kendi diğer yapıları içerenler gibi çeşitli dilim türleri için böyle birkaç ortak şey tanımladığım bir yarar kitaplığı var.

Evet, lineer zamanda çalışıyor, ama mesele bu değil. Mesele, Go'nun hangi ortak dil yapılarına sahip olup olmadığını sormak ve öğrenmektir. İyi bir egzersiz. Bu cevabın aptalca veya yararlı olup olmadığı okuyucuya bağlıdır.