slices.Delete

定義如下：

func Delete[S ~[]E, E any](s S, i, j int) S

從 s 中刪除元素 s[i:j]，返回修改后的切片。如果 s[i:j] 不是 s 的有效切片，則會(huì) panic。Delete是 O(len(s)-j)，因此如果必須刪除許多項(xiàng)，最好調(diào)用一次刪除全部，而不是逐個(gè)刪除。Delete不能修改元素 s[len(s)-(j-i):len(s)]。如果這些元素包含指針，可以考慮將這些元素歸零，以便它們引用的對(duì)象可以被垃圾回收。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    letters := []string{"a", "b", "c", "d", "e"}
    letters = slices.Delete(letters, 1, 4)
    fmt.Println(letters) // [a e]
}

slices.DeleteFunc

定義如下：

func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S

從 s 中刪除 del函數(shù)返回 true 的元素，并返回修改后的切片。當(dāng) DeleteFunc 刪除m個(gè)元素時(shí)，它可能不會(huì)修改元素s[len(s)-m:len(s)]。如果這些元素包含指針，、可以考慮將這些元素歸零，以便它們引用的對(duì)象可以被垃圾回收。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    seq := []int{0, 1, 1, 2, 3, 5, 8}
    seq = slices.DeleteFunc(seq, func(n int) bool {
        return n%2 != 0 // 刪除奇數(shù)
    })
    fmt.Println(seq) // [0 2 8]
}

slices.Equal

定義如下：

func Equal[S ~[]E, E comparable](s1, s2 S) bool

判斷兩個(gè)切片是否相等（長(zhǎng)度相同且所有元素相等）。如果長(zhǎng)度不同，返回 false。如果長(zhǎng)度相同，將按索引遞增的順序比較元素，并在第一個(gè)不相等出現(xiàn)時(shí)停止比較。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    numbers := []int{0, 42, 8}
    fmt.Println(slices.Equal(numbers, []int{0, 42, 8})) // true
    fmt.Println(slices.Equal(numbers, []int{10})) // false
}

slices.EqualFunc

定義如下：

func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool

對(duì)每對(duì)元素使用自定義函數(shù)來(lái)判斷兩個(gè)片是否相等。如果長(zhǎng)度不同，返回false。如果長(zhǎng)度相同，將按索引遞增的順序比較元素，并在 eq 返回 false 的第一個(gè)索引處停止比較。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
    "strconv"
)
func main() {
    numbers := []int{0, 42, 8}
    strings := []string{"000", "42", "0o10"}
    equal := slices.EqualFunc(numbers, strings, func(n int, s string) bool {
        sn, err := strconv.ParseInt(s, 0, 64)
        if err != nil {
            return false
        }
        return n == int(sn)
    })
    fmt.Println(equal) // true
}

slices.Grow

定義如下：

func Grow[S ~[]E, E any](s S, n int) S

增加片的容量，以為另外 n 個(gè)元素提供空間。在Grow(n)之后，至少可以將n個(gè)元素添加到片中，而無(wú)需再進(jìn)行分配。如果 n 為負(fù)值或太大而無(wú)法分配內(nèi)存，就會(huì) panic。

slices.Index

定義如下：

func Index[S ~[]E, E comparable](s S, v E) int

返回 v 在 s 中第一次出現(xiàn)的索引，如果不存在則返回-1。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    numbers := []int{0, 42, 8}
    fmt.Println(slices.Index(numbers, 8)) // 2
    fmt.Println(slices.Index(numbers, 7)) // -1
}

slices.IndexFunc

定義如下：

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

返回第一個(gè)滿足 f(s[i]) 的索引 i，如果不滿足則返回-1。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    numbers := []int{0, 42, -10, 8}
    i := slices.IndexFunc(numbers, func(n int) bool {
        return n < 0
    })
    fmt.Println("First negative at index", i) // 2
}

slices.Insert

定義如下：

func Insert[S ~[]E, E any](s S, i int, v ...E) S

將 值 v… 在索引 i 處插入到 s，返回修改后的切片。s[i:] 中的元素被上移以騰出空間。在返回的切片 r 中，r[i] == v[0]， r[i+len(v)] == 原來(lái)在 r[i] 處的 value。如果超出范圍，則 panic。這個(gè)函數(shù)的復(fù)雜度為 O(len(s) + len(v))。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    names := []string{"Alice", "Bob", "Vera"}
    names = slices.Insert(names, 1, "Bill", "Billie")
    names = slices.Insert(names, len(names), "Zac")
    fmt.Println(names) // [Alice Bill Billie Bob Vera Zac]
}

slices.IsSorted

定義如下：

func IsSorted[S ~[]E, E cmp.Ordered](x S) bool

判斷 x 是否按升序排序。簡(jiǎn)單示例如下：

package main
import (
    "fmt"
    "slices"
)
func main() {
    fmt.Println(slices.IsSorted([]string{"Alice", "Bob", "Vera"})) // true
    fmt.Println(slices.IsSorted([]int{0, 2, 1})) // false
}

【參考資料】

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

到此這篇關(guān)于Go1.21新增slices包中函數(shù)的用法詳解的文章就介紹到這了,更多相關(guān)Go1.21 slices包內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論