Un article pour vous aider à comprendre les bases du découpage de langue Go-Golang-php.cn

Un article pour vous aider à comprendre les bases du découpage de langue Go

Go语言进阶学习

Libérer： 2023-07-20 14:59:47

avant

1110 Les gens l'ont consulté

Pourquoi avons-nous besoin de découpage

À l'origine, nous avons appris les arrays, et nous savons que les tableaux peuvent stocker beaucoup de choses.

Code

package main

import "fmt"

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

Copier après la connexion

Le code ci-dessus définit un tableau et stocke 4 valeurs, mais que se passe-t-il s'il stocke 5 valeurs ou plus.

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)
}

Copier après la connexion

Conclusion : Le tableau ne peut stocker qu'une longueur fixe et ne peut pas ajouter de valeurs. Si une valeur est ajoutée, une erreur sera signalée.

Ainsi, la structure de stockage en chaîne suivante est dérivée.

切片

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

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

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

Un article pour vous aider à comprendre les bases du découpage de langue Go

如何验证。

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，表示不是地址
    如果是堆中存储，打印的就直接是地址
*/

Copier après la connexion

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

开始使用切片

官话

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

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

声明切片

语法如下。

方式一(声明变量方式)

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


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

Copier après la connexion

方式二(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]
}

Copier après la connexion

由数组得到的切片

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

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)
}

Copier après la connexion

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)
}

Copier après la connexion

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) //[          八神 张三 李四 王五 小刘]
}

Copier après la connexion

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

修改切片中的元素(改)

修改就简单了，同数组。

package main

import "fmt"

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

Copier après la connexion

删除切片中的元素(删)

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

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

package main

import "fmt"

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

Copier après la connexion

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

切片遍历(查)

切片的遍历同数组一样。

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)
  }
}

Copier après la connexion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!