Чи має конструкція "if x in" схожа на Python?

Не можу переглядати весь масив, як я можу перевірити, чи є xв масиві за допомогою Go? Чи є в мові конструкція?

Як і Python: if "x" in array: ...

Немає вбудованого оператора, який би це зробив у Go. Потрібно перебрати через масив. Ви можете написати свою власну функцію, як це зробити:

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

Якщо ви хочете мати змогу перевірити на членство, не повторюючи весь список, вам потрібно використовувати мапу замість масиву чи фрагмента, наприклад:

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

Ще одне рішення, якщо список містить статичні значення.

наприклад: перевірка дійсного значення зі списку допустимих значень:

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

Це цитата з книги "Програмування в роботі: Створення програм для 21 століття":

Використання простого лінійного пошуку, подібного до цього, є єдиним варіантом для несортованих даних і добре для невеликих фрагментів (до сотень елементів). Але для великих фрагментів, особливо якщо ми проводимо пошук неодноразово - лінійний пошук є дуже неефективним, в середньому вимагає порівнювати половину елементів кожного разу.

Go забезпечує метод sort.Search (), який використовує алгоритм двійкового пошуку: Для цього потрібно щоразу порівнювати лише елементи log2 (n) (де n - кількість елементів). Для того, щоб зробити це перспективним, для лінійного пошуку 1000000 предметів потрібно в середньому 500000 порівнянь, з гіршим випадком 1000000 порівнянь; двійковий пошук потребує не більше 20 порівнянь, навіть у гіршому випадку.

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

Наведений вище приклад використання сортування близький, але у разі рядків просто використовуйте 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

Просто було подібне запитання і вирішили спробувати деякі пропозиції з цієї теми.

Я порівняв найкращі та найгірші сценарії 3 типів пошуку:

• за допомогою карти
• використовуючи список
• за допомогою оператора switch

ось код функції:

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
}

Найкращі сценарії вибирають перший елемент у списках, у гірших випадках - неіснуюче значення.

ось результати:

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

Перемикач перемагає до кінця, найгірший випадок надзвичайно швидший, ніж найкращий випадок. Карти найгірші, і список ближче до переключення.

Тож мораль полягає в тому, що якщо у вас є статичний, досить невеликий список, заява про перемикання - це шлях.

Інший варіант - використання карти як набору. Ви використовуєте лише ключі, і значення має бути на зразок булевого, що завжди відповідає дійсності. Тоді ви можете легко перевірити, чи карта містить ключ чи ні. Це корисно, якщо вам потрібна поведінка набору, якщо, якщо ви додаєте значення кілька разів, це лише в наборі один раз.

Ось простий приклад, коли я додаю випадкові числа як ключі до карти. Якщо одне і те ж число генерується більше одного разу, це не має значення, воно з’явиться в кінцевій карті лише один раз. Тоді я використовую простий, якщо перевірте, чи є ключ на карті чи ні.

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

Ось вона на ігровому майданчику

Це настільки близько, як я можу дістатись до природного відчуття оператора "в" Python. Ви повинні визначити власний тип. Тоді ви можете розширити функціональність цього типу, додавши метод типу "має", який веде себе так, як ви сподівалися.

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

У мене є бібліотека утиліт, де я визначаю декілька загальних речей, подібних до цієї, для кількох типів фрагментів, таких як цілі числа чи інші мої структури.

Так, це працює в лінійний час, але це не в тому. Сенс полягає в тому, щоб запитати і дізнатися, які спільні мовні конструкції Go мають, а що не мають. Це гарна вправа. Чи є ця відповідь дурною чи корисною, залежить від читача.