腳本之家服務器常用軟件

快捷導航

Go1.21新增slices包的用法詳解

更新時間：2023年08月17日 08:41:38 作者：路多辛

Go?1.21新增的?slices?包提供了很多和切片相關的函數，可以用于任何類型的切片,這篇文章主要來和大家介紹一下slices包中相關函數的用法，需要的可以參考一下

slices.BinarySearch

定義如下：

func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)

在已經排好序的切片（切片必須按遞增順序排序）中搜索目標，如果找到了，返回所在的位置和 true，如果沒有找到，則返回目標應該被找到的位置和 false，簡單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := []string{"Alice", "Bob", "Vera"}
    n, found := slices.BinarySearch(names, "Vera")
    fmt.Println("Vera:", n, found) // Vera: 2 true
    n, found = slices.BinarySearch(names, "Bill")
    fmt.Println("Bill:", n, found) // Bill: 1 false
}

slices.BinarySearchFunc

定義如下：

func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)

作用類似 slices.BinarySearch，不同的是使用自定義比較函數。切片必須按遞增順序排序，其中“遞增”是由cmp定義的。如果 slice 元素與目標匹配，CMP應該返回 0，如果 slice元素在目標之前，則返回一個負數，如果 slice 元素在目標之后，則返回一個正數。CMP必須實現與片相同的排序，這樣，如果CMP (a, t) < 0且CMP (b, t) >= 0，則切中的 a 必須位于 b 之前。

package main
import (
    "cmp"
    "fmt"
    "slices"
)
func main() {
    type Person struct {
        Name string
        Age  int
    }
    people := []Person{
        {"Alice", 55},
        {"Bob", 24},
        {"Gopher", 13},
    }
    n, found := slices.BinarySearchFunc(people, Person{"Bob", 0}, func(a, b Person) int {
        return cmp.Compare(a.Name, b.Name)
    })
    fmt.Println("Bob:", n, found) // Bob: 1 true
}

slices.Clip

定義如下：

func Clip[S ~[]E, E any](s S) S

從切片中刪除未使用的容量，返回 s[:len(s):len(s)]。簡單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := make([]string, 2, 5)
    names = slices.Clip(names)
    fmt.Printf("長度：%d,容量：%d", len(names), cap(names))
  // 長度：2,容量：2
}

slices.Clone

定義如下：

func Clone[S ~[]E, E any](s S) S

返回切片的副本。因為元素是使用賦值方式復制的，所以這是一個淺克隆。簡單實用方法如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := []string{"路多辛的博客", "路多辛的所思所想"}
    namesCopy := slices.Clone(names)
    fmt.Println(namesCopy)
}

slices.Compact

定義如下：

func Compact[S ~[]E, E comparable](s S) S

將連續(xù)出現的元素變?yōu)橐粋€，類似于 Unix 上的 uniq 命令。Compact 會修改片的內容并返回修改后的片，長度可能會變得更小。簡單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    seq := []int{0, 1, 1, 2, 5, 5, 5, 8}
    seq = slices.Compact(seq)
    fmt.Println(seq) // [0 1 2 5 8]
}

slices.CompactFunc

定義如下：

func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S

類似于 slices.Compact，不同的是使用自定義的函數來比較元素。如果元素的運行結果相等，CompactFunc 將保留第一個元素。簡單示例如下：

package main
import (
    "fmt"
    "slices"
    "strings"
)
func main() {
    names := []string{"bob", "Bob", "alice", "Vera", "VERA"}
    names = slices.CompactFunc(names, func(a, b string) bool {
        return strings.ToLower(a) == strings.ToLower(b)
    })
    fmt.Println(names) // [bob alice Vera]
}

slices.Compare

定義如下：

func Compare[S ~[]E, E cmp.Ordered](s1, s2 S) int

使用 cmp.Compare函數來比較 s1 和 s2 的元素。按照順序比較每一對元素，直到一個元素不等于另一個元素。返回第一個不匹配元素的結果。如果兩個切片在其中一個結束之前相等，則認為較短的切片小于較長的切片。如果 s1 == s2，結果為0；如果 s1 < s2，結果為-1；如果 s1 > s2，結果為1。

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := []string{"Alice", "Bob", "Vera"}
    fmt.Println("Equal:", slices.Compare(names, []string{"Alice", "Bob", "Vera"}))
    fmt.Println("V < X:", slices.Compare(names, []string{"Alice", "Bob", "Xena"}))
    fmt.Println("V > C:", slices.Compare(names, []string{"Alice", "Bob", "Cat"}))
    fmt.Println("3 > 2:", slices.Compare(names, []string{"Alice", "Bob"}))
}

運行結果如下：

Equal: 0
V < X: -1
V > C: 1
3 > 2: 1

slices.CompareFunc

定義如下：

func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int

類似于 slices.Compare，不同的是使用自定義的比較函數進行比較。結果是 cmp 的第一個非零結果；如果 cmp 總是返回0，則如果 len(s1) == len(s2) 結果為0，如果len(s1) < len(s2)結果為-1，如果 len(s1) > len(s2) 結果為1。簡單示例如下：

package main
import (
    "cmp"
    "fmt"
    "slices"
    "strconv"
)
func main() {
    numbers := []int{0, 43, 8}
    strings := []string{"0", "0", "8"}
    result := slices.CompareFunc(numbers, strings, func(n int, s string) int {
        sn, err := strconv.Atoi(s)
        if err != nil {
            return 1
        }
        return cmp.Compare(n, sn)
    })
    fmt.Println(result) // 1
}

slices.Contains

定義如下：

func Contains[S ~[]E, E comparable](s S, v E) bool

用于判斷 s 是否包含 v。簡單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := []string{"Alice", "Bob", "Vera"}
    fmt.Println(slices.Contains(names, "Bob")) // true
}

slices.ContainsFunc

定義如下：

func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool

用于判斷 s 中是否至少有一個元素 e 滿足 f(e)。簡單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    numbers := []int{0, 42, -10, 8}
    hasNegative := slices.ContainsFunc(numbers, func(n int) bool {
        return n < 0
    })
    fmt.Println("Has a negative:", hasNegative)// true
    hasOdd := slices.ContainsFunc(numbers, func(n int) bool {
        return n%2 != 0
    })
    fmt.Println("Has an odd number:", hasOdd) // false
}

【參考資料】

Package slices（https://golang.google.cn/pkg/slices/）

以上就是Go1.21新增slices包的用法詳解的詳細內容，更多關于Go1.21 slices包的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: