golang이 있습니까?-Golang-php.cn

golang에는 없습니다. Golang은 유사한 Python 연산자를 제공하지 않으며 PHP의 in_array와 같은 다른 언어와 같은 표준 라이브러리 함수도 제공하지 않습니다. 이유: 1. in 함수의 구현은 매우 간단하고 불필요합니다. 2. 다양한 시나리오에서는 고정된 방법이 아닌 실제 상황에 따라 어떤 방법을 구현할지 분석해야 합니다.

golang이 있습니까?

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

전에 Zhihu에서 질문을 봤습니다. 왜 Golang에는 Python과 동일한 기능이 없나요? 그래서 이 질문을 검색해 보니 아직도 이런 질문을 갖고 계신 분들이 많더군요.

오늘은 이 주제에 대해 이야기해 보겠습니다.

in은 매우 일반적으로 사용되는 함수입니다. 일부 언어에서는 포함이라고도 합니다. 언어마다 표현이 다르지만 기본적으로는 있습니다. 하지만 불행하게도 Go는 유사한 Python 연산자를 제공하지 않으며 PHP의 in_array와 같은 다른 언어와 같은 표준 라이브러리 함수도 제공하지 않습니다.

Go의 철학은 Less is more를 추구하는 것입니다. 아마도 Go 팀에서는 이것이 구현하기에 실용적이지 않은 기능이라고 생각할 것 같습니다.

왜 하찮다고 하시나요? 직접 구현하고 싶다면 어떻게 해야 할까요?

제가 생각할 수 있는 구현 방법은 세 가지가 있습니다. 하나는 순회, 다른 하나는 정렬의 이진 검색, 세 번째는 맵의 키 인덱스입니다.

Traversal

Traversal은 우리가 쉽게 생각할 수 있는 가장 간단한 구현 방법이어야 합니다.

예제는 다음과 같습니다.

func InIntSlice(haystack []int, needle int) bool {
    for _, e := range haystack {
        if e == needle {
            return true
        }
    }

    return false
}

로그인 후 복사

위는 []int형 변수에 지정된 int가 존재하는지 알아내는 방법을 보여줍니다. 아주 간단하죠? 이것에서도 제가 구현하기가 사소하다고 말한 이유를 알 수 있습니다. .

이 예제에는 결함이 있습니다. 단일 유형만 지원합니다. 해석된 언어와 같은 일반적인 기능을 지원하려면 리플렉션을 사용해야 합니다.

코드는 다음과 같습니다.

func In(haystack interface{}, needle interface{}) (bool, error) {
    sVal := reflect.ValueOf(haystack)
    kind := sVal.Kind()
    if kind == reflect.Slice || kind == reflect.Array {
        for i := 0; i < sVal.Len(); i++ {
            if sVal.Index(i).Interface() == needle {
                return true, nil
            }
        }

        return false, nil
    }

    return false, ErrUnSupportHaystack
}

로그인 후 복사

더 다양하게 활용하기 위해 In 함수의 입력 매개변수 haystack과 needle은 모두 인터페이스{} 유형입니다.

인터페이스{}인 모든 입력 매개변수의 이점에 대해 간략하게 이야기해 보겠습니다. 다음과 같은 두 가지 주요 사항이 있습니다.

첫째, haystack은 인터페이스{} 유형이므로 in에서 지원하는 유형은 단순히 슬라이스뿐만 아니라 배열도 가능합니다. 함수가 내부적으로 리플렉션을 통해 haystack에 대한 유형 검사를 수행하고 슬라이스와 배열을 지원한다는 것을 알 수 있습니다. 다른 유형인 경우 맵과 같은 새로운 유형 지원을 추가하는 것은 실제로 매우 간단합니다. 하지만 이 방법은 권장되지 않습니다. 왜냐하면 in의 효과는 _, ok := m[k] 구문을 통해 얻을 수 있기 때문입니다.
둘째, haystack은 인터페이스{}이고, []인터페이스{}도 요구 사항을 충족하며 needle은 인터페이스{}입니다. 이런 방식으로 해석된 언어와 동일한 효과를 얻을 수 있습니다.

어떻게 이해하셨나요? 직접적인 예는 다음과 같습니다:

gotin.In([]interface{}{1, "two", 3}, "two")

로그인 후 복사

haystack은 []interface{}{1, "two", 3}이고 needle은 인터페이스{}이며 이때 값은 "two"입니다. 해석된 언어에서 요소는 모든 유형이 될 수 있으며 동일한 효과를 가질 필요는 없는 것 같습니다. 이런 식으로 우리는 원하는대로 사용할 수 있습니다.

하지만 주목해야 할 점은 In 함수 구현에 다음과 같은 코드가 있다는 것입니다.

if sVal.Index(i).Interface() == needle {
    ...
}

로그인 후 복사

Go의 모든 유형을 ==를 사용하여 비교할 수 있는 것은 아닙니다. 요소에 슬라이스나 맵이 포함되어 있으면 오류가 발생합니다. 보고될 수 있습니다.

이진 검색

요소가 있는지 확인하기 위해 순회할 때 단점이 있습니다. 즉, 배열이나 슬라이스에 1,000,000개, 즉 100만 개의 데이터가 포함되어 있는 경우 , 최악의 시나리오는 확인하는 데 1,000,000번이 걸리고 시간 복잡도가 On이라는 것입니다.

순회 횟수를 줄이는 방법이 있나요?

생각나는 자연스러운 방법은 시간 복잡도가 log2(n)인 이진 검색입니다. 하지만 이 알고리즘에는 전제 조건이 있으며 순서가 지정된 시퀀스에 의존합니다.

그래서 우리가 해결해야 할 첫 번째 문제는 시퀀스를 정렬하는 것입니다. Go의 표준 라이브러리는 이미 정렬 패키지에 이 기능을 제공합니다.

샘플 코드는 다음과 같습니다.

fmt.Println(sort.SortInts([]int{4, 2, 5, 1, 6}))

로그인 후 복사

[]int의 경우 사용하는 함수는 SortInts입니다. 다른 유형의 슬라이스인 경우 sort는 관련 함수도 제공합니다. 예를 들어 []string은 SortStrings로 정렬할 수 있습니다. .

정렬 후에는 이진 검색을 수행할 수 있습니다. 다행히 Go에서는 []int 유형에 해당하는 기능이 SearchInts입니다.

이 함수를 간략하게 소개하고 먼저 정의를 살펴보겠습니다.

func SearchInts(a []int, x int) int

로그인 후 복사

입력 매개변수는 이해하기 쉽습니다. 슬라이스 a에서 x를 검색하세요. 핵심은 반환 값에 대해 이야기하는 것인데, 이는 나중에 해당 요소가 존재하는지 확인하는 데 매우 중요합니다. 반환값의 의미는 슬라이스 내 요소의 위치를 반환한다는 의미이며, 해당 요소가 존재하지 않는 경우에는 슬라이스를 순서대로 유지하면서 해당 요소를 삽입해야 하는 위치를 반환해준다.

예를 들어, 순서는 다음과 같습니다:

1 2 6 8 9 11

로그인 후 복사

가정, x는 6이고 검색 후 해당 위치는 인덱스 2에 있음을 발견합니다. x가 7이면 해당 요소가 존재하지 않는 것으로 발견됩니다. , 그리고 시퀀스에 삽입되면 6과 8 사이에 배치되며 인덱스 위치는 3이므로 반환 값은 3입니다.

코드 테스트:

fmt.Println(sort.SearchInts([]int{1, 2, 6, 8, 9, 11}, 6)) // 2
fmt.Println(sort.SearchInts([]int{1, 2, 6, 8, 9, 11}, 7)) // 3

로그인 후 복사

如果判断元素是否在序列中，只要判断返回位置上的值是否和查找的值相同即可。

但还有另外一种情况，如果插入元素位于序列最后，例如元素值为 12，插入位置即为序列的长度 6。如果直接查找 6 位置上的元素就可能发生越界的情况。那怎么办呢？其实判断返回是否小于切片长度即可，小于则说明元素不在切片序列中。

完整的实现代码如下：

func SortInIntSlice(haystack []int, needle int) bool {
    sort.Ints(haystack)
    
    index := sort.SearchInts(haystack, needle)
    return index < len(haystack) && haystack[index] == needle
}

로그인 후 복사

但这还有个问题，对于无序的场景，如果每次查询都要经过一次排序并不划算。最好能实现一次排序，稍微修改下代码。

func InIntSliceSortedFunc(haystack []int) func(int) bool {
    sort.Ints(haystack)
    
    return func(needle int) bool {
        index := sort.SearchInts(haystack, needle)
        return index < len(haystack) && haystack[index] == needle
    }
}

로그인 후 복사

上面的实现，我们通过调用 InIntSliceSortedFunc 对 haystack 切片排序，并返回一个可多次使用的函数。

使用案例如下：

in := gotin.InIntSliceSortedFunc(haystack)

for i := 0; i<maxNeedle; i++ {
    if in(i) {
        fmt.Printf("%d is in %v", i, haystack)
    }
}

로그인 후 복사

二分查找的方式有什么不足呢？

我想到的重要一点，要实现二分查找，元素必须是可排序的，如 int，string，float 类型。而对于结构体、切片、数组、映射等类型，使用起来就不是那么方便，当然，如果要用，也是可以的，不过需要我们进行一些适当扩展，按指定标准排序，比如结构的某个成员。

到此，二分查找的 in 实现就介绍完毕了。

map key

本节介绍 map key 方式。它的算法复杂度是 O1，无论数据量多大，查询性能始终不变。它主要依赖的是 Go 中的 map 数据类型，通过 hash map 直接检查 key 是否存在，算法大家应该都比较熟悉，通过 key 可直接映射到索引位置。

我们常会用到这个方法。

_, ok := m[k]
if ok {
    fmt.Println("Found")
}

로그인 후 복사

那么它和 in 如何结合呢？一个案例就说明白了这个问题。

假设，我们有一个 []int 类型变量，如下：

s := []int{1, 2, 3}

로그인 후 복사

为了使用 map 的能力检查某个元素是否存在，可以将 s 转化 map[int]struct{}。

m := map[interface{}]struct{}{
    1: struct{}{},
    2: struct{}{},
    3: struct{}{},
    4: struct{}{},
}

로그인 후 복사

如果检查某个元素是否存在，只需要通过如下写法即可确定：

k := 4
if _, ok := m[k]; ok {
    fmt.Printf("%d is found\n", k)
}

로그인 후 복사

是不是非常简单？

补充一点，关于这里为什么使用 struct{}，可以阅读我之前写的一篇关于 Go 中如何使用 set 的文章。

按照这个思路，实现函数如下：

func MapKeyInIntSlice(haystack []int, needle int) bool {
    set := make(map[int]struct{})
    
    for _ , e := range haystack {
        set[e] = struct{}{}
    }
    
    _, ok := set[needle]
    return ok
}

로그인 후 복사

实现起来不难，但和二分查找有着同样的问题，开始要做数据处理，将 slice 转化为 map。如果是每次数据相同，稍微修改下它的实现。

func InIntSliceMapKeyFunc(haystack []int) func(int) bool {
    set := make(map[int]struct{})

    for _ , e := range haystack {
        set[e] = struct{}{}
    }

    return func(needle int) bool {
        _, ok := set[needle]
        return ok
    }
}

로그인 후 복사

对于相同的数据，它会返回一个可多次使用的 in 函数，一个使用案例如下：

in := gotin.InIntSliceMapKeyFunc(haystack)

for i := 0; i<maxNeedle; i++ {
    if in(i) {
        fmt.Printf("%d is in %v", i, haystack)
    }
}

로그인 후 복사

对比前两种算法，这种方式的处理效率最高，非常适合于大数据的处理。接下来的性能测试，我们将会看到效果。

性能

介绍完所有方式，我们来实际对比下每种算法的性能。测试源码位于 gotin_test.go 文件中。

基准测试主要是从数据量大小考察不同算法的性能，本文中选择了三个量级的测试样本数据，分别是 10、1000、1000000。

为便于测试，首先定义了一个用于生成 haystack 和 needle 样本数据的函数。

代码如下：

func randomHaystackAndNeedle(size int) ([]int, int){
    haystack := make([]int, size)

    for i := 0; i<size ; i++{
        haystack[i] = rand.Int()
    }

    return haystack, rand.Int()
}

로그인 후 복사

输入参数是 size，通过 http://rand.Int() 随机生成切片大小为 size 的 haystack 和 1 个 needle。在基准测试用例中，引入这个随机函数生成数据即可。

举个例子，如下：

func BenchmarkIn_10(b *testing.B) {
    haystack, needle := randomHaystackAndNeedle(10)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, _ = gotin.In(haystack, needle)
    }
}

로그인 후 복사

首先，通过 randomHaystackAndNeedle 随机生成了一个含有 10 个元素的切片。因为生成样本数据的时间不应该计入到基准测试中，我们使用 b.ResetTimer() 重置了时间。

其次，压测函数是按照 Test+函数名+样本数据量规则编写，如案例中 BenchmarkIn_10，表示测试 In 函数，样本数据量为 10。如果我们要用 1000 数据量测试 InIntSlice，压测函数名为 BenchmarkInIntSlice_1000。

测试开始吧！简单说下我的笔记本配置，Mac Pro 15 版，16G 内存，512 SSD，4 核 8 线程的 CPU。

测试所有函数在数据量在 10 的情况下的表现。

$ go test -run=none -bench=10$ -benchmem

로그인 후 복사

匹配所有以 10 结尾的压测函数。

测试结果：

goos: darwin
goarch: amd64
pkg: github.com/poloxue/gotin
BenchmarkIn_10-8                         3000000               501 ns/op             112 B/op         11 allocs/op
BenchmarkInIntSlice_10-8                200000000                7.47 ns/op            0 B/op          0 allocs/op
BenchmarkInIntSliceSortedFunc_10-8      100000000               22.3 ns/op             0 B/op          0 allocs/op
BenchmarkSortInIntSlice_10-8            10000000               162 ns/op              32 B/op          1 allocs/op
BenchmarkInIntSliceMapKeyFunc_10-8      100000000               17.7 ns/op             0 B/op          0 allocs/op
BenchmarkMapKeyInIntSlice_10-8           3000000               513 ns/op             163 B/op          1 allocs/op
PASS
ok      github.com/poloxue/gotin        13.162s

로그인 후 복사

表现最好的并非 SortedFunc 和 MapKeyFunc，而是最简单的针对单类型的遍历查询，平均耗时 7.47ns/op，当然，另外两种方式表现也不错，分别是 22.3ns/op 和 17.7ns/op。

表现最差的是 In、SortIn（每次重复排序）和 MapKeyIn（每次重复创建 map）两种方式，平均耗时分别为 501ns/op 和 513ns/op。

测试所有函数在数据量在 1000 的情况下的表现。

$ go test -run=none -bench=1000$ -benchmem

로그인 후 복사

测试结果：

goos: darwin
goarch: amd64
pkg: github.com/poloxue/gotin
BenchmarkIn_1000-8                         30000             45074 ns/op            8032 B/op       1001 allocs/op
BenchmarkInIntSlice_1000-8               5000000               313 ns/op               0 B/op          0 allocs/op
BenchmarkInIntSliceSortedFunc_1000-8    30000000                44.0 ns/op             0 B/op          0 allocs/op
BenchmarkSortInIntSlice_1000-8             20000             65401 ns/op              32 B/op          1 allocs/op
BenchmarkInIntSliceMapKeyFunc_1000-8    100000000               17.6 ns/op             0 B/op          0 allocs/op
BenchmarkMapKeyInIntSlice_1000-8           20000             82761 ns/op           47798 B/op         65 allocs/op
PASS
ok      github.com/poloxue/gotin        11.312s

로그인 후 복사

表现前三依然是 InIntSlice、InIntSliceSortedFunc 和 InIntSliceMapKeyFunc，但这次顺序发生了变化，MapKeyFunc 表现最好，17.6 ns/op，与数据量 10 的时候相比基本无变化。再次验证了前文的说法。

同样的，数据量 1000000 的时候。

$ go test -run=none -bench=1000000$ -benchmem

로그인 후 복사

测试结果如下：

goos: darwin
goarch: amd64
pkg: github.com/poloxue/gotin
BenchmarkIn_1000000-8                                 30          46099678 ns/op         8000098 B/op    1000001 allocs/op
BenchmarkInIntSlice_1000000-8                       3000            424623 ns/op               0 B/op          0 allocs/op
BenchmarkInIntSliceSortedFunc_1000000-8         20000000                72.8 ns/op             0 B/op          0 allocs/op
BenchmarkSortInIntSlice_1000000-8                     10         138873420 ns/op              32 B/op          1 allocs/op
BenchmarkInIntSliceMapKeyFunc_1000000-8         100000000               16.5 ns/op             0 B/op          0 allocs/op
BenchmarkMapKeyInIntSlice_1000000-8                   10         156215889 ns/op        49824225 B/op      38313 allocs/op
PASS
ok      github.com/poloxue/gotin        15.178s

로그인 후 복사

MapKeyFunc 依然表现最好，每次操作用时 17.2 ns，Sort 次之，而 InIntSlice 呈现线性增加的趋势。一般情况下，如果不是对性能要特殊要求，数据量特别大的场景，针对单类型的遍历已经有非常好的性能了。

从测试结果可以看出，反射实现的通用 In 函数每次执行需要进行大量的内存分配，方便的同时，也是以牺牲性能为代价的。

总结

本文通过一个问题引出主题，为什么 Go 中没有类似 Python 的 In 方法。我认为，一方面是实现非常简单，没有必要。除此以外，另一方面，在不同场景下，我们还需要根据实际情况分析用哪种方式实现，而不是一种固定的方式。

接着，我们介绍了 In 实现的三种方式，并分析了各自的优劣。通过性能分析测试，我们能得出大致的结论，什么方式适合什么场景，但总体还是不能说足够细致，有兴趣的朋友可以继续研究下。

【相关推荐：Go视频教程、编程教学】

위 내용은 golang이 있습니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!