An article to help you understand the basics of Go language slicing

Why slicing is needed

In the original time, we learnedArray, we know that arrays can store many things.

Code

package main

import "fmt"

func main() {
    var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"}
    fmt.Println(student_list)
}

The above code defines an array and stores 4 values, but if 5 is stored value or more.

package main

import "fmt"

func main() {
    //方式一，在创建的时候就多加一个值
    // 只能存4个，多了会报错，array index 4 out of bounds [0:4]
    //var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"，"小七"}

    //方式二，通过索引方式添加值
    var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"}
    //还是会报错，invalid array index 4 (out of bounds for 4-element array)
    //student_list[4] = "小七"
    fmt.Println(student_list)
}

Conclusion:Arrays can only store fixed lengths and cannot append values. If you append a value An error will be reported.

So, the following chain storage structure is derived.

切片

切片，在其他语言中，在Python中叫列表，Java中好像也是列表，PHP中也叫列表，只是在Go中叫切片(slice)

切片(列表)在每个编程语言中，都是一个非常通用的存储结构。

属于堆内存存储，其内存分布图如下。

如何验证。

package main

import "fmt"

func main() {
    var student_list = []string{"张三"， "李四"}         //[]里面没有加长度是切片
    var student_list2 = [3]string{"张三"， "李四"， "王五"} //[]里面加长度是数组
    fmt.Printf("%p\n"， student_list)                //结果:0xc000096440
    fmt.Printf("%p\n"， student_list2)               //结果:%!p([3]string=[张三 李四 王五])，表示不是地址
}
/*
    %p表示直接打印的是变量地址
    如果是栈中存储的，是打印不出来地址的，显示%!p，表示不是地址
    如果是堆中存储，打印的就直接是地址
*/

ps:默认打印，赋值等操作，操作的是栈上面的值，所以堆存储直接打印的就是堆的地址，赋值等其他操作同理。

开始使用切片

官话

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型(堆存储)，它的内部结构包含地址，长度和容量。切片一般用于快速地操作一块数据集合。

声明切片

语法如下。

方式一(声明变量方式)

语法
var 变量名 []存储类型
例如:
package main


/*
    和数组操作方式非常像，[]不加数字，就是切片
*/
func main() {
    var student_list []string
    var student_list2 []int
    var student_list3 []float64
    
    //类型推断方式，后面必须带{}，数组同理
    var student_list4 = []string{}
}

方式二(make方式)

语法:
var 变量名 = make([]存储类型， 切片中元素数量， 切片的容量)
变量名 := make([]int， 10， 20)
/*
    切片容量不写等于切片元素数量
*/

例如:
package main

import "fmt"

func main() {
    var student_list4 = make([]int， 10， 20)
    fmt.Println(student_list4)//结果:[0 0 0 0 0 0 0 0 0 0]
}

由数组得到的切片

注:数组得到的，只能是切片

package main

import "fmt"

func main() {
    var name_array = [5]int{1， 2， 3， 4， 5}
    var name_slice = name_array[1:3] //name_array[1:3]切完值以后，结果只能是切片
    fmt.Printf("%T %T\n"， name_array， name_slice)
}

ps:数组通过下标范围([开始下标:结束下标])的方式获取的值，只能是列表，取值包含左下标，不包含右下标

简称顾左不顾右。

向切片中追加元素(增)

终于到了每个语言的必学的环节了，切片的增加操作。

在Go中，向切片中追加值，需要用到append。

package main

import "fmt"

func main() {
    var student_list []string
    //append追加之后，必须使用student_list再接收
    student_list = append(student_list， "张三")
    student_list = append(student_list， "李四")
    student_list = append(student_list， "王五")
    fmt.Println(student_list)
}

ps:apppend之后，必须使用原来的变量再接受一次

一次性增加多个

如果一个列表，需要增加另外一个列表怎么办呢？？？

package main

import "fmt"

func main() {
    //var student_list []string
    var student_list1 = []string{"张三"， "李四"， "王五"， "小刘"}
    var student_list2 = make([]string， 10)
    student_list2 = append(student_list2， "八神")       //添加一个值
    student_list2 = append(student_list2， "八神"， "九尾") //可以添加多个值
    student_list2 = append(student_list2， student_list1...)
    //下面这种写法，就是上面...所包含的意思，专业叫法叫做打散，
    //student_list2 = append(student_list2，"张三"， "李四"， "王五"， "小刘")

    fmt.Println(student_list2) //[          八神 张三 李四 王五 小刘]
}

注:可能有人会注意到，八神前面会有很多空格，这个先别着急，后面揭晓。

修改切片中的元素(改)

修改就简单了，同数组。

package main

import "fmt"

func main() {
    var names = []string{"张三"， "李四"}
    names[1] = "李四666" //修改下标为1的值
    fmt.Println(names) //[张三 李四666]
}

删除切片中的元素(删)

比较尴尬的是，Go中的切片，在做删除这个操作，不是太友好。

下面举个例子，希望能看懂，看不懂会用就行。

package main

import "fmt"

func main() {
    var names = []string{"张三"， "李四"， "王五"， "小刘"， "七阿"}
    //删除索引为2的元素
    names = append(names[:2]， names[3:]...) //删除王五
    fmt.Println(names)                      //[张三 李四 小刘 七阿]
}

如果看不懂，没关系，下章会好好捋捋这个。

切片遍历(查)

切片的遍历同数组一样。

package main

import "fmt"

func main() {
    var names = []string{"张三"， "李四"， "王五"， "小刘"， "七阿"}
    //方式一，标准for循环
    for i := 0; i < len(names); i++ {
        fmt.Println(names[i])
}
    //方式二，for range
    for index， value := range names {
        //index为下标，value为值
        fmt.Println(index， value)
  }
}

The above is the detailed content of An article to help you understand the basics of Go language slicing. For more information, please follow other related articles on the PHP Chinese website!