슬라이스 방법이 들어 있습니다

슬라이스 방법이 들어 있습니다

---

slice.contains(object)조각의 각 요소를 검색하지 않고도 Go 의 메소드 와 비슷한 것이 있습니까?

---

Mostafa는 이미 그러한 방법을 작성하는 것이 쉽지 않다고 지적했으며 mkb는 정렬 패키지에서 이진 검색을 사용하는 힌트를 제공했습니다. 그러나 이러한 포함 검사를 많이 수행하려는 경우 맵을 대신 사용할 수도 있습니다.

value, ok := yourmap[key]관용구 를 사용하여 특정 맵 키가 있는지 확인하는 것은 쉽지 않습니다 . 값에 관심이 없으므로 map[string]struct{}예를 들어 만들 수도 있습니다 . struct{}여기 에 빈 공간을 사용하면 추가 공간이 필요하지 않으며 Go의 내부지도 유형이 해당 종류의 값에 최적화되어 있다는 이점이 있습니다. 따라서 map[string] struct{}Go 세계에서 인기있는 세트입니다.

---

아니요, 그러한 방법은 존재하지 않지만 작성하기는 쉽지 않습니다.

func contains(s []int, e int) bool {
    for _, a := range s {
        if a == e {
            return true
        }
    }
    return false
}

조회가 코드의 중요한 부분 인 경우 맵을 사용할 수 있지만 맵에 비용이 많이 듭니다.

---

슬라이스가 정렬되어있는 경우, 구현 이진 검색이 패키지 .sort

---

를 사용하는 대신 더 나은 솔루션 slice일 map수 있습니다.

간단한 예 :

package main

import "fmt"


func contains(slice []string, item string) bool {
    set := make(map[string]struct{}, len(slice))
    for _, s := range slice {
        set[s] = struct{}{}
    }

    _, ok := set[item] 
    return ok
}

func main() {

    s := []string{"a", "b"}
    s1 := "a"
    fmt.Println(contains(s, s1))

}

http://play.golang.org/p/CEG6cu4JTf

---

리플렉션 패키지를 사용하여 구체적인 유형이 슬라이스 인 인터페이스를 반복 할 수 있습니다 .

func HasElem(s interface{}, elem interface{}) bool {
    arrV := reflect.ValueOf(s)

    if arrV.Kind() == reflect.Slice {
        for i := 0; i < arrV.Len(); i++ {

            // XXX - panics if slice element points to an unexported struct field
            // see https://golang.org/pkg/reflect/#Value.Interface
            if arrV.Index(i).Interface() == elem {
                return true
            }
        }
    }

    return false
}

https://play.golang.org/p/jL5UD7yCNq

---

키를 기반으로 항목을 찾기 위해 맵을 사용할 수없는 경우 goderive 도구를 고려할 수 있습니다 . Goderive는 contains 메소드의 유형별 구현을 생성하여 코드를 읽기 쉽고 효율적으로 만듭니다.

예;

type Foo struct {
    Field1 string
    Field2 int
} 

func Test(m Foo) bool {
     var allItems []Foo
     return deriveContainsFoo(allItems, m)
}

To generate the deriveContainsFoo method:

• Install goderive with go get -u github.com/awalterschulze/goderive
• Run goderive ./... in your workspace folder

This method will be generated for deriveContains:

func deriveContainsFoo(list []Foo, item Foo) bool {
    for _, v := range list {
        if v == item {
            return true
        }
    }
    return false
}

Goderive has support for quite some other useful helper methods to apply a functional programming style in go.

---

Not sure generics are needed here. You just need a contract for your desired behavior. Doing the following is no more than what you would have to do in other languages if you wanted your own objects to behave themselves in collections, by overriding Equals() and GetHashCode() for instance.

type Identifiable interface{
    GetIdentity() string
}

func IsIdentical(this Identifiable, that Identifiable) bool{
    return (&this == &that) || (this.GetIdentity() == that.GetIdentity())
}

func contains(s []Identifiable, e Identifiable) bool {
    for _, a := range s {
        if IsIdentical(a,e) {
            return true
        }
    }
    return false
}

---

func Contain(target interface{}, list interface{}) (bool, int) {
    if reflect.TypeOf(list).Kind() == reflect.Slice || reflect.TypeOf(list).Kind() == reflect.Array {
        listvalue := reflect.ValueOf(list)
        for i := 0; i < listvalue.Len(); i++ {
            if target == listvalue.Index(i).Interface() {
                return true, i
            }
        }
    }
    if reflect.TypeOf(target).Kind() == reflect.String && reflect.TypeOf(list).Kind() == reflect.String {
        return strings.Contains(list.(string), target.(string)), strings.Index(list.(string), target.(string))
    }
    return false, -1
}

---

The sort package provides the building blocks if your slice is sorted or you are willing to sort it.

input := []string{"bird", "apple", "ocean", "fork", "anchor"}
sort.Strings(input)

fmt.Println(contains(input, "apple")) // true
fmt.Println(contains(input, "grow"))  // false

...

func contains(s []string, searchterm string) bool {
    i := sort.SearchStrings(s, searchterm)
    return i < len(s) && s[i] == searchterm
}

SearchString promises to return the index to insert x if x is not present (it could be len(a)), so a check of that reveals whether the string is contained the sorted slice.

참고URL : https://stackoverflow.com/questions/10485743/contains-method-for-a-slice