Go에“if x in”구성이 Python과 비슷합니까?

전체 배열을 반복 하지 않고x Go를 사용하여 배열에서 어떻게 확인할 수 있습니까? 언어에는 구문이 있습니까?

파이썬처럼 : 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
}

이것은 "Goving Programming : 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

sort를 사용하는 위의 예제는 비슷하지만 문자열의 경우 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

스위치가 끝까지 이기고 최악의 경우가 최상의 경우보다 훨씬 빠릅니다. 지도가 최악이고 목록이 더 가깝습니다.

따라서 도덕은 다음과 같습니다. 정적이고 합리적으로 작은 목록이있는 경우 switch 문을 사용하십시오.

다른 옵션은 맵을 세트로 사용하는 것입니다. 키만 사용하고 값이 항상 true 인 부울과 같아야합니다. 그러면지도에 키가 포함되어 있는지 쉽게 확인할 수 있습니다. 이것은 세트의 동작이 필요할 때 유용합니다. 값을 여러 번 추가하면 세트에 한 번만 있습니다.

다음은지도에 임의의 숫자를 키로 추가하는 간단한 예입니다. 같은 숫자가 두 번 이상 생성되면 중요하지 않으며, 최종 맵에만 한 번만 나타납니다. 그런 다음 키가 맵에 있는지 여부를 확인하려면 간단한 경우를 사용하십시오.

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

여기 운동장에 있어요

이것은 파이썬의 "in"연산자의 자연스러운 느낌에 도달 할 수있는 한 가깝습니다. 자신의 유형을 정의해야합니다. 그런 다음 원하는대로 동작하는 "has"와 같은 메소드를 추가하여 해당 유형의 기능을 확장 할 수 있습니다.

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가 가지고 있고 가지고 있지 않은 공통 언어 구성에 대해 묻고 배우는 것입니다. 좋은 운동입니다. 이 답변이 어리 석거나 유용한 지 여부는 독자에게 달려 있습니다.