玩转 Go Slices 切片泛型库

简介: 本文全面介绍了 Go slices 库的所有函数,并着重指出了使用某些函数时的注意事项,通过阅读本文,相信你将能够熟练掌握如何使用 Go Slices 库。

本文中涉及到的相关代码,都已上传至:github.com/chenmingyong0423/blog/tree/master/tutorial-code/slices

前言

Go 1.21.0 版本中,引入了 切片泛型库,它提供了很多有用的函数,特别是在搜索、查找和排序等方面,为我们开发者提供了诸多便利之处。而本文将会对 slices 库提供的函数进行介绍,准备好了吗,准备一杯你喜欢的咖啡或茶,随着本文一探究竟吧。

slices

slices 库包含的函数可以分为以下类型:

  • 搜索:通过二分查找算法查找指定元素。相关的函数有 BinarySearchBinarySearchFunc

  • 裁剪:删除切片中未使用的容量。相关的函数有 Clip

  • 克隆:浅拷贝一个切片副本。相关的的函数有:Clone

  • 压缩:将切片里连续的相同元素替换为一个元素。从而减少了切片的长度,相关的函数有:CompactCompactFunc

  • 大小比较:比较两个切片的大小。相关的函数有 CompareCompareFunc

  • 包含:判断切片是否包含指定元素。相关的函数有:ContainsContainsFunc

  • 删除:从切片中删除一个或多个元素。相关的函数有 DeleteDeleteFunc

  • 等价比较:比较两个切片是否相等。相关的函数有:EqualEqualFunc

  • 扩容:增加切片的容量。相关的函数有:Grow

  • 索引查找:查找指定元素在切片中的索引位置。相关的函数有:IndexIndexFunc

  • 插入:往切片里插入一组值。相关的函数有:Insert

  • 有序判断:判断切片是否按照升序排列。相关的函数有:IsSortedIsSortedFunc

  • 最大值:查找切片里的最大元素。相关的函数有:MaxMaxFunc

  • 最小值:查找切片里的最小元素。相关的函数有:MinMinFunc

  • 替换:替换切片里的元素。相关的函数有:Replace

  • 反转:反转切片的元素。相关的函数有:Reverse

  • 排序:对切片里的元素进行升序排列。相关的函数有:SortSortFunc 以及 SortStableFunc

搜索:BinarySearch 和 BinarySearchFunc

BinarySearch

BinarySearch 函数用于在有序的切片中 查找 目标元素,并返回其在切片中的 位置。该函数有两个返回值,第一个是指定元素的下标索引,第二个是一个 bool 值,表示是否在切片中找到指定元素。

下面是使用该函数的一个例子:

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/binary_search/binary_search.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    scores := []int{
   70, 85, 90, 95, 98, 99, 100}
    idx, b := slices.BinarySearch(scores, 80)
    fmt.Println(idx, b)
    idx, b = slices.BinarySearch(scores, 95)
    fmt.Println(idx, b)
}

程序运行结果如下所示:

1 false
3 true

BinarySearchFunc

BinarySearchFunc 功能和 BinarySearch 类似,但它更加灵活,在它接收的参数里,其中有一个是 cmp 比较函数,通过该函数我们可以为任何的数据结构定义比较逻辑。

cmp 比较函数的介绍如下:

cmp func(E, T) int

  • E:切片元素
  • T:目标元素
  • 返回值为 int 类型

E 的位置在 T 之前,返回负数;当前 E 等于 T 时,应返回 0,当 E 的位置在 T 的后面时,返回正数。

下面是使用该函数的一个例子:

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/binary_search/binary_search_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
)

func main() {
   
    type User struct {
   
       Name string
       Age  int
    }

    users := []User{
   
       {
   "Aaron", 20},
       {
   "Gopher", 24},
       {
   "Harry", 18},
    }

    idx, b := slices.BinarySearchFunc(users, User{
   Name: "Gopher"}, func(src User, dst User) int {
   
       return cmp.Compare(src.Name, dst.Name)
    })
    fmt.Println("Gopher:", idx, b)
}

在比较函数里,如果不是要实现特别复杂的比较,我们完全可以使用 cmp 包提供的 Compare 函数。

程序运行结果如下所示:

Gopher: 1 true

裁剪:Clip

Clip 函数用于删除切片中未使用的容量,执行操作后,切片的长度 = 切片的容量。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/clip/clip.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    s := make([]int, 0, 8)
    s = append(s, 1, 2, 3, 4)
    fmt.Printf("len: %d, cap: %d\n", len(s), cap(s))
    s = slices.Clip(s)
    fmt.Printf("len: %d, cap: %d\n", len(s), cap(s))
}

程序运行结果如下所示:

len: 4, cap: 8
len: 4, cap: 4

克隆:Clone

Clone 函数返回一个拷贝的切片副本,元素是赋值复制,因此是浅拷贝。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/clone/clone.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    type User struct {
   
       Name string
    }
    s := []*User{
   {
   Name: "Gopher"}}
    copiedSlice := slices.Clone(s)

    copiedSlice[0].Name = "陈明勇"

    fmt.Println(s[0].Name == copiedSlice[0].Name) // true
}

由于是浅拷贝,修改副本切片里的元素,原切片的元素也会更新。

压缩:Compact 和 CompactFunc

Compact

Compact 函数会将切片里连续的相同元素替换为一个元素。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/compact/compact.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    s := []int{
   1, 2, 2, 3, 3, 4, 5}
    newSlice := slices.Compact(s)
    fmt.Println(newSlice)
}

程序运行结果如下所示:

[1 2 3 4 5]

Compact 的原理是通过移动元素来合并重复项。尽管处理后的切片长度减少了,但其底层数组的实际值仍然包括被“抛弃”的元素,例如 [1, 2, 3, 4, 5, 4, 5]。这些尾部的元素 [4, 5] 虽不在新切片中,但仍占用内存。特别是当元素为指针时,这些元素会阻止它们所引用的对象被垃圾回收。为确保这些对象可以被回收,我们应该考虑将这些元素置为 nil

CompactFunc

CompactFuncCompact 函数功能类似,但它使用一个相等性函数来比较元素。

案例:相同元素合并为一个,比较元素时,忽略大小写

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/compact/compact_func.go
package main

import (
    "fmt"
    "slices"
    "strings"
)

func main() {
   
    names := []string{
   "cmy", "CmY", "Gopher", "GOPHER", "Jack"}
    names = slices.CompactFunc(names, func(a, b string) bool {
   
       return strings.ToLower(a) == strings.ToLower(b)
    })
    fmt.Println(names)
}

程序运行结果如下所示:

[cmy Gopher Jack]

大小比较:Compare 和 CompareFunc

Compare

Compare 函数是一个比较函数,内部使用 cmp 包的 Compare 函数对 s1s2 的每对元素进行比较。元素按顺序从索引 0 开始进行比较,直到有一对元素不相等。返回第一对不匹配元素的比较结果。如果两个切片在某一个切片结束之前都保持相等,那么长度较短的切片被认为小于较长的切片。

如果 s1 == s2,结果为 0;如果 s1 < s2,结果为 -1;如果 s1 > s2,结果为 +1

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/compare/compare.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    names := []string{
   "Aaron", "Bob", "Gopher"}
    fmt.Println("相等: ", slices.Compare(names, []string{
   "Aaron", "Bob", "Gopher"}))
    fmt.Println("G < F, 第一个的切片小于第二个的切片:", slices.Compare(names, []string{
   "Aaron", "Bob", "Frida"}))
    fmt.Println("G > H, 第一个的切片大于第二个的切片:", slices.Compare(names, []string{
   "Aaron", "Bob", "Harry"}))
    fmt.Println("3 > 2, 第一个的切片大于第二个的切片:", slices.Compare(names, []string{
   "Aaron", "Bob"}))
}

程序运行结果如下所示:

相等:  0
G < F, 第一个的切片小于第二个的切片: 1
G > H, 第一个的切片大于第二个的切片: -1
3 > 2, 第一个的切片大于第二个的切片: 1

CompareFunc

CompareFuncCompare 函数的功能类似,但它对每对元素使用自定义的比较函数进行比较。比较函数在 BinarySearchFunc 小节里已经介绍过,这里就不多介绍。

案例:使用自定义的比较函数来比较两个切片中的元素,此比较函数基于字符串的长度而不是字典顺序。比较规则是:更短的字符串被认为是较小的。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/compare/compare_func.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    s1 := []string{
   "apple", "banana", "cherry"}
    s2 := []string{
   "apple", "blueberry", "date"}
    result := slices.CompareFunc(s1, s2, func(s string, s2 string) int {
   
       if len(s) < len(s2) {
   
          return -1
       } else if len(s) > len(s2) {
   
          return 1
       }
       return 0
    })
    fmt.Println("第一个切片比第二个切片小:", result) // -1
}

程序运行结果如下所示:

第一个切片比第二个切片小: -1

包含:Contains 和 ContainsFunc

Contains

Contains 函数用于判断切片里是否包含指定元素。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/contains/contains.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 5, -1, 3, 2}
    hasNegativeOne := slices.Contains(numbers, -1)
    fmt.Println("包含 -1:", hasNegativeOne)
}

程序运行结果如下所示:

包含 -1: true

ContainsFunc

ContainsFuncContains 函数功能类似,但它使用一个相等性函数来确定被包含的元素。

例如我们要在一个切片中判断是否包含负数元素:

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/contains/contains_func.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 5, -1, 3, 2}
    containNegative := slices.ContainsFunc(numbers, func(i int) bool {
   
       return i < 0
    })
    fmt.Println("包含负数:", containNegative)
}

程序运行结果如下所示:

包含负数: true

删除:Delete 和 DeleteFunc

Delete

Delete 函数的功能是从指定切片 s 中删除指定范围 s[i:j] 的元素,并返回新的的切片。

使用注意事项:

  • 如果 s[i:j] 不是一个有效的范围,则会 panic
  • 相比于逐个删除的行为,一次性删除多个元素,效率会更好
  • 由于该函数底层是通过索引范围去构建新的切片,并没有操作被 “抛弃”的元素。它们仍然存在于底层的数组中。因此当元素为指针时,这些元素会阻止它们所引用的对象被垃圾回收。为确保这些对象可以被回收,我们应该考虑将这些元素置为 nil

下面是使用该函数的一个例子:

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/delete/delete.go
package main

import (
    "fmt"
    "slices"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    newNumbers := slices.Delete(numbers, 1, 3)
    fmt.Println(newNumbers)
}

程序运行结果如下所示:

[1 4 5]

删除位置范围 1 ~ 3 的元素,不包含位置 3

DeleteFunc

DeleteFuncDelete 函数功能类似,但它使用一个相等性函数来确定需要删除的元素。

案例:从切片中删除奇数元素

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/delete/delete_func.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 2, 3, 4, 5}
    newNumbers := slices.DeleteFunc(numbers, func(i int) bool {
   
        return i%2 != 0
    })
    fmt.Println(newNumbers)
}

程序运行结果如下所示:

[2 4]

等价比较:Equal 和 EqualFunc

Equal

Equal 函数用于比较两个切片是否相等,要求切片的元素类型必须是可比较(comparable)的。
其工作原理如下:

首先检查两个切片的长度,如果长度不同,则直接返回 false,表示这两个切片不相等。如果长度相同,函数会逐个比较元素,按照递增的顺序进行比较。需要注意的是,对于浮点数,函数会忽略 NaN 值,不将其视为相等。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/equal/equal.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   0, 1, 2}
    fmt.Println(slices.Equal(numbers, []int{
   0, 1, 2}))
    fmt.Println(slices.Equal(numbers, []int{
   3}))
}

程序运行结果如下所示:

true
false

EqualFunc

EqualFuncEqual 函数功能类似,但它使用一个相等性函数来比较元素。

案例:忽略大小写比较

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/equal/equal_func.go
package main

import (
    "fmt"
    "slices"
    "strings"
)

func main() {
   
    names := []string{
   "cmy", "Gopher"}
    equal := slices.EqualFunc(names, []string{
   "CMY", "GOPHER"}, func(s string, s2 string) bool {
   
       return strings.ToLower(s) == strings.ToLower(s2)
    })
    fmt.Println(equal)
}

程序运行结果如下所示:

true

扩容:Grow

Grow 函数会根据需要增加切片的容量,以确保可以容纳另外 n 个元素。在调用 Grow(n) 后,至少可以追加 n 个元素到切片中而无需再次分配内存。如果 n 为负数或者需要分配的内存太大,Grow 会引发异常。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/grow/grow.go
package main

import (
    "fmt"
    "slices"
)

func main() {
    s := make([]int, 4, 5)
    fmt.Printf("len=%d, cap=%d\n", len(s), cap(s))
    grow := slices.Grow(s, 4)
    fmt.Printf("len=%d, cap=%d\n", len(grow), cap(grow))
}

程序运行结果如下所示:

len=4, cap=5
len=4, cap=10

在调用 Grow 函数扩容之前,切片 s 可用容量只有 1,在扩容之后,可用容量为 6,可确保能至少能容纳 4 个元素。

索引查找:Index 和 IndexFunc

Index

Index 函数返回指定元素在切片里第一次出现的下标索引值,如果元素不存在,则返回 -1

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/index/index.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   0, 1, 2}
    fmt.Println("找到元素位置:", slices.Index(numbers, 2))
    fmt.Println("未找到元素位置:", slices.Index(numbers, 3))
}

程序运行结果如下所示:

找到元素位置: 2
未找到元素位置: -1

IndexFunc

IndexFuncIndex 函数功能类似,但它使用一个相等性函数来比较元素。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/index/index_func.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 5, -1, 3, 2}
    idx := slices.IndexFunc(numbers, func(i int) bool {
   
        return i < 0
    })
    fmt.Println("负数的索引:", idx)
}

程序运行结果如下所示:

负数的索引: 2

插入:Insert

Insert 函数用于在一个切片 s 中的指定位置 i 处插入一组值 v...,然后返回修改后的切片。如果指定的索引 i 越界了,则会发生错误。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/insert/insert.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 3, 4}
    numbers = slices.Insert(numbers, 1, 2)
    numbers = slices.Insert(numbers, len(numbers), 5, 6)
    fmt.Println(numbers)
}

程序运行结果如下所示:

[1 2 3 4 5 6]

有序判断:IsSorted 和 IsSortedFunc

IsSorted

IsSorted 函数用于判断切片是按升序排列。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/is_sorted/is_sorted.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    fmt.Println("是升序排列:", slices.IsSorted([]int{
   1, 2, 3, 4, 5}))
    fmt.Println("不是升序排列:", slices.IsSorted([]int{
   1, 2, 3, 5, 4}))
}

程序运行结果如下所示:

是升序排列: true
不是升序排列: false

IsSortedFunc

IsSortedFuncIsSorted 函数功能类似,但它对每对元素使用自定义的比较函数进行比较。比较函数在 BinarySearchFunc 小节里已经介绍过,这里就不多介绍。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/is_sorted/is_sorted_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
    "strings"
)

func main() {
   
    names := []string{
   "aaron", "Bob", "GOPHER"}
    isSortedInsensitive := slices.IsSortedFunc(names, func(a, b string) int {
   
        return cmp.Compare(strings.ToLower(a), strings.ToLower(b))
    })
    fmt.Println("是升序排列:", isSortedInsensitive)
    fmt.Println("不是升序排列:", slices.IsSorted(names))
}

程序运行结果如下所示:

是升序排列: true
不是升序排列: false

最大值:Max 和 MaxFunc

Max

Max 函数返回切片中最大的元素,如果切片为空,则 panic。对于浮点数类型,如果切片中包含 NaN(非数字)值,那么结果将是 NaNNaN 是一种特殊的浮点数值,表示不是一个数字或无效数字。如果切片包含 NaN,那么最大值也将是 NaN,这是因为 NaN 不可比较大小。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/max/max.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    fmt.Println("最大的元素:", slices.Max([]int{
   1, 2, 5, 3, 4}))
}

程序运行结果如下所示:

最大的元素: 5

MaxFunc

MaxFuncMax 函数功能类似,但它使用一个相等性函数来比较元素。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/max/max_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
)

func main() {
   
    type User struct {
   
        Name string
        Age  int
    }

    users := []User{
   
        {
   "Aaron", 20},
        {
   "Gopher", 24},
        {
   "Harry", 18},
    }
    maxUser := slices.MaxFunc(users, func(a, b User) int {
   
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println("最大的元素:", maxUser)
}

程序运行结果如下所示:

最大的元素: {Gopher 24}

最小值:Min 和 MinFunc

Min

Min 函数返回切片中最小的元素,如果切片为空,则 panic。对于浮点数类型,如果切片中包含 NaN(非数字)值,那么结果将是 NaNNaN 是一种特殊的浮点数值,表示不是一个数字或无效数字。如果切片包含 NaN,那么最小值也将是 NaN,这是因为 NaN 不可比较大小。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/min/min.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    fmt.Println("最小的元素:", slices.Max([]int{
   1, 2, 5, 3, 4}))
}

程序运行结果如下所示:

最小的元素: 1

MaxFunc

MaxFuncMax 函数功能类似,但它使用一个相等性函数来比较元素。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/min/min_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
)

func main() {
   
    type User struct {
   
        Name string
        Age  int
    }

    users := []User{
   
        {
   "Aaron", 20},
        {
   "Gopher", 24},
        {
   "Harry", 18},
    }
    maxUser := slices.MaxFunc(users, func(a, b User) int {
   
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println("最小的元素:", maxUser)
}

程序运行结果如下所示:

最小的元素: {Harry 18}

替换:Replace

Replace 函数用于将切片s 中的元素 s[i:j] 替换为给定的元素组 v,然后返回修改后的切片。如果 s[i:j] 不是 s 的有效切片范围,函数会引发 panic

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/replace/replace.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 0, 0, 5}
    numbers = slices.Replace(numbers, 1, 3, 2, 3, 4)
    fmt.Println(numbers)
}

程序运行结果如下所示:

[1 2 3 4 5]

反转:Reverse

Reverse 函数用于反转切片中的元素,在给定切片里将元素的顺序颠倒过来,而不会创建新的切片。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/reverse/reverse.go
package main

import (
    "fmt"
    "slices"
)

func main() {
   
    numbers := []int{
   1, 2, 3, 4}
    slices.Reverse(numbers)
    fmt.Println(numbers)
}

程序运行结果如下所示:

[4 3 2 1]

排序:Sort 和 SortFunc 以及 SortStableFunc

Sort

Sort 函数用于对切片中的元素进行升序排序。当对浮点数进行排序时,NaN 值会被排在其他值的前面。这意味着在排序浮点数时,NaN 值会被视为最小值,排在结果的最前面。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/sort/sort.go
package main

import (
    "fmt"
    "math"
    "slices"
)

func main() {
   
    ints := []int{
   1, 2, 5, 3, 4}
    slices.Sort(ints)
    floats := []float64{
   2.0, 3.0, math.NaN(), 1.0}
    slices.Sort(floats)
    fmt.Println(ints)
    fmt.Println(floats)
}

程序运行结果如下所示:

[1 2 3 4 5]
[NaN 1 2 3]

SortFunc

SortFuncSort 函数功能类似,但它对每对元素使用自定义的比较函数进行比较。比较函数在 BinarySearchFunc 小节里已经介绍过,这里就不多介绍。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/sort/sort_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
    "strings"
)

func main() {
   
    names := []string{
   "Bob", "Aaron", "GOPHER"}
    slices.SortFunc(names, func(a, b string) int {
   
        return cmp.Compare(strings.ToLower(a), strings.ToLower(b))
    })
    fmt.Println(names)
}

程序运行结果如下所示:

[1 2 3 4 5]
[NaN 1 2 3]

SortStableFunc

SortStableFuncSortFunc 函数功能类似,但它进行的是稳定排序,它会保持相等元素的原始顺序。

定排序意味着当有多个相等的元素时,它们的相对顺序在排序后会保持不变。例如,如果有两个元素 AB,它们的值相等,且在原始切片中 A 出现在 B 之前,那么在排序后 A`仍然会出现在B` 之前,不会改变它们的相对位置。

// https://github.com/chenmingyong0423/blog/blob/master/tutorial-code/slices/sort/sort_stable_func.go
package main

import (
    "cmp"
    "fmt"
    "slices"
)

func main() {
   
    type User struct {
   
        Name string
        Age  int
    }

    users := []User{
   
        {
   "Aaron", 20},
        {
   "Gopher", 16},
        {
   "Harry", 16},
        {
   "Burt", 18},
    }
    slices.SortStableFunc(users, func(a, b User) int {
   
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println(users)
}

程序运行结果如下所示:

[{Gopher 16} {Harry 16} {Burt 18} {Aaron 20}]

排序之前,HarryGopher 后面,排序之后,也是同样的相对位置。

小结

本文全面介绍了 Go slices 库的所有函数,并着重指出了使用某些函数时的注意事项,通过阅读本文,相信你将能够熟练掌握如何使用 Go Slices 库。

本文中涉及到的相关代码,都已上传至:github.com/chenmingyong0423/blog/tree/master/tutorial-code/slices

目录
相关文章
|
7天前
|
IDE Go 开发工具
一文搞懂Go1.18泛型新特性
一文搞懂Go1.18泛型新特性
20 0
|
7天前
|
安全 Go
这一次,带你深入浅出Go语言切片和数组
这一次,带你深入浅出Go语言切片和数组
17 0
|
24天前
|
测试技术 Go 开发者
go-carbon v2.3.8 发布,轻量级、语义化、对开发者友好的 golang 时间处理库
carbon 是一个轻量级、语义化、对开发者友好的 golang 时间处理库,支持链式调用。
17 0
|
1天前
|
Java 测试技术 Go
Go语言标准库进阶应用与最佳实践:提升代码质量与性能
【2月更文挑战第8天】在掌握了Go语言标准库的基础应用后,如何进一步发掘其潜力,提升代码质量和性能,是每位Go语言开发者所关心的问题。本文将探讨Go语言标准库的进阶应用与最佳实践,包括标准库与其他库的协同使用、性能优化与内存管理、错误处理与异常捕获、标准库在实际项目中的应用案例,以及推荐的最佳实践与编程规范。通过深入了解这些内容,开发者能够更好地利用Go语言标准库,提升代码质量与性能,构建出更加高效、可靠的软件应用。
|
1天前
|
算法 安全 Go
Go语言标准库核心模块详解:构建高效应用的基石
【2月更文挑战第8天】Go语言标准库中的核心模块为开发者提供了构建高效应用所需的基础功能和工具。本文将深入探讨Go语言标准库中的几个核心模块,包括容器与集合、并发与并行、输入输出、时间与日期、字符串处理以及加密与安全,帮助读者更好地理解和应用这些核心模块,为构建高效应用打下坚实基础。
|
1天前
|
Go API 数据安全/隐私保护
Go语言标准库概览:构建高效、可靠的软件开发基石
【2月更文挑战第8天】Go语言标准库是Go语言生态系统的重要组成部分,它为开发者提供了一系列高效、可靠的工具和函数,帮助开发者构建高质量的软件应用。本文将对Go语言标准库进行概览,介绍其组成特点、设计哲学以及使用场景与优势,帮助读者更好地理解和应用Go语言标准库。
|
9天前
|
Go 索引
Go 1.22 slices 库的更新:高效拼接、零化处理和越界插入优化
本文详细介绍了 Go 1.22 版本中 slices 库的更新内容,总结起来有三个方面:新增了 Concat 函数、对部分函数新增了零化处理的逻辑和对 Insert 函数进行了越界插入优化
51 1
Go 1.22 slices 库的更新:高效拼接、零化处理和越界插入优化
|
29天前
|
Go Unix 开发者
Go语言time库,时间和日期相关的操作方法
Go语言time库,时间和日期相关的操作方法
38 0
Go语言time库,时间和日期相关的操作方法
|
1月前
|
Go 开发者
Go语言插件开发:Pingo库实践
Go语言插件开发:Pingo库实践
13 0
|
1月前
|
编译器 Go
go语言中的math库
go语言中的math库
25 0

相关产品

  • 云迁移中心