golang 切片

本文视频教程：https://www.bilibili.com/vide…

后面咱们学习了数组，数组是固定长度，能够包容雷同数据类型的元素的汇合。当长度固定时，应用还是带来一些限度，比方：咱们申请的长度太大节约内存，太小又不够用。

鉴于上述起因，咱们有了 go 语言的切片，能够把切片了解为，可变长度的数组，其实它底层就是应用数组实现的，减少了 主动扩容 性能。切片（Slice）是一个领有雷同类型元素的可变长度的序列。

go 语言切片的语法

申明一个切片和申明一个数组相似，只有不增加长度就能够了

var identifier []type

切片是援用类型，能够应用 make 函数来创立切片：

var slice1 []type = make([]type, len)

也能够简写为

slice1 := make([]type, len)

也能够指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

go 语言切片实例

package main

import "fmt"

func main() {var names []string
    var numbers []int
    fmt.Printf("names: %v\n", names)
    fmt.Printf("numbers: %v\n", numbers)
    fmt.Println(names == nil)
    fmt.Println(numbers == nil)
}

运行后果

names: []
numbers: []
true
true

go 语言切片的长度和容量

切片领有本人的长度和容量，咱们能够通过应用内置的 len() 函数求长度，应用内置的 cap() 函数求切片的容量。

实例

package main

import "fmt"

func main() {var names = []string{"tom", "kite"}
    var numbers = []int{1, 2, 3}

    fmt.Printf("len: %d cap: %d\n", len(names), cap(names))
    fmt.Printf("len: %d cap: %d\n", len(numbers), cap(numbers))

    var s1 = make([]string, 2, 3)
    fmt.Printf("len: %d cap: %d\n", len(s1), cap(s1))
}

运行后果

len: 2 cap: 2
len: 3 cap: 3
len: 2 cap: 3

golang 切片的初始化

切片的初始化办法很多，能够间接初始化，也能够应用数组初始化等。

切片如何切分

// 切片
func test1() {var s1 = []int{1, 2, 3, 4, 5, 6}
    s2 := s1[0:3] // [)
    fmt.Printf("s2: %v\n", s2)
    s3 := s1[3:]
    fmt.Printf("s3: %v\n", s3)
    s4 := s1[2:5]
    fmt.Printf("s4: %v\n", s4)
    s5 := s1[:]
    fmt.Printf("s5: %v\n", s5)
}

间接初始化

package main

import "fmt"

func main() {s := []int{1, 2, 3}
    fmt.Printf("s: %v\n", s)
}

运行后果

s: [1 2 3]

应用数组初始化

package main

import "fmt"

func main() {arr := [...]int{1, 2, 3}
    s1 := arr[:]
    fmt.Printf("s1: %v\n", s1)
}

运行后果

s1: [1 2 3]

应用数组的局部元素初始化（切片表达式）

切片的底层就是一个 数组 ，所以咱们能够 基于数组通过切片表达式失去切片 。切片表达式中的 low 和 high 示意一个索引范畴（ 左蕴含，右不蕴含 ），失去的切片 长度=high-low，容量等于失去的切片的底层数组的容量。

package main

import "fmt"

func main() {arr := [...]int{1, 2, 3, 4, 5, 6}
    s1 := arr[2:5]
    fmt.Printf("s1: %v\n", s1)
    s2 := arr[2:]
    fmt.Printf("s2: %v\n", s2)
    s3 := arr[:3]
    fmt.Printf("s3: %v\n", s3)
}

运行后果

s1: [3 4 5]
s2: [3 4 5 6]
s3: [1 2 3]

空 (nil) 切片

一个切片在未初始化之前默认为 nil，长度为 0，容量为 0.

package main

import "fmt"

func main() {var s1 []int
    fmt.Println(s1 == nil)
    fmt.Printf("len: %d, cap: %d\n", len(s1), cap(s1))
}

运行后果

true
len: 0, cap: 0

go 语言切片的遍历

切片的遍历和数组的遍历十分相似，能够应用 for 循环索引遍历，或者 for range 循环。

for 循环索引遍历

package main

import "fmt"

func main() {s1 := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(s1); i++ {fmt.Printf("s1[%d]: %v\n", i, s1[i])
    }
}

运行后果

s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5

for range 循环

package main

import "fmt"

func main() {s1 := []int{1, 2, 3, 4, 5}
    for i, v := range s1 {fmt.Printf("s1[%d]: %v\n", i, v)
    }
}

运行后果

s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5

go 语言切片元素的增加和删除 copy

切片是一个动静数组，能够应用 append() 函数增加元素，go 语言中并没有删除切片元素的专用办法，咱们能够应用切片自身的个性来删除元素。因为，切片是援用类型，通过赋值的形式，会批改原有内容，go 提供了 copy() 函数来拷贝切片

增加元素

package main

import "fmt"

func main() {s1 := []int{}
    s1 = append(s1, 1)
    s1 = append(s1, 2)
    s1 = append(s1, 3, 4, 5) // 增加多个元素
    fmt.Printf("s1: %v\n", s1)

    s3 := []int{3, 4, 5}
    s4 := []int{1, 2}
    s4 = append(s4, s3...) // 增加另外一个切片
    fmt.Printf("s4: %v\n", s4)
}

运行后果

s1: [1 2 3 4 5]
s4: [1 2 3 4 5]

删除元素

package main

import "fmt"

func main() {s1 := []int{1, 2, 3, 4, 5}
    // 删除索引为 2 的元素
    s1 = append(s1[:2], s1[3:]...)
    fmt.Printf("s1: %v\n", s1)
}

运行后果

s1: [1 2 4 5]

公式：要从切片 a 中删除索引为 index 的元素，操作方法是a = append(a[:index], a[index+1:]...)

拷贝切片

package main

import "fmt"

func main() {s1 := []int{1, 2, 3}
    s2 := s1
    s1[0] = 100
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s2: %v\n", s2)
    fmt.Println("----------")

    s3 := make([]int, 3)

    copy(s3, s1)

    s1[0] = 1

    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s3: %v\n", s3)
}

运行后果

s1: [100 2 3]
s2: [100 2 3]
-------------
s1: [1 2 3]
s3: [100 2 3]

从运行后果，咱们看到赋值的状况下，原来的变量被批改了，应用 copy 函数，原来的变量没有被批改。

关注公众号，学习更多 golang 常识