Parlons des tranches en langage Go

Cet article vous fera découvrir le "tableau" de longueur variable dans golang - slice J'espère qu'il vous sera utile !

golang slice (slice)

(1) Définition de slice

Une tranche (Slice) est une séquence de longueur variable avec des éléments du même type. Il s'agit d'une couche d'encapsulation basée sur le type de tableau. Il est très flexible et prend en charge l'expansion automatique.

Une tranche est un type de référence et sa structure interne contient l'adresse, la longueur et la capacité. Les tranches sont généralement utilisées pour opérer rapidement sur une collection de données. [Recommandation associée : Tutoriel vidéo Go]

La seule différence entre la création d'une tranche et la création d'un tableau est de savoir s'il y a un nombre dans le "[]" avant Type. S'il est vide, il représente une tranche, sinon il. représente un tableau. Parce que les tranches ont une longueur variable

var a []string  //声明一个字符串切片
var b = []int{1,2,3} //声明一个整数类型切片并初始化
var c = []bool{false,true} //声明一个bool类型并且初始化

En fait, dans des situations réelles, elles sont souvent comprises comme : les tranches font partie du tableau

num:=[3]int{0,1,2}
//:前后表示数组内部的索引
sc1:=num[:] //获取数组的全部
sc2:=num[0:2] //左闭右开，取到的是[0,1]
sc3:=num[1:] //取到的是[2]
sc4:=num[:1]  //取到的是[0]

(2) Utilisez la fonction make pour créer des tranches

Ici commence à correspondre à la précédent En d'autres termes, la capacité d'une tranche peut être rendue variable en utilisant la fonction make. L'essence d'une tranche est d'encapsuler le tableau sous-jacent. Elle contient trois informations : le pointeur du tableau sous-jacent, la longueur de. la tranche (len) et la capacité de la tranche (cap).

// make([]T, size, cap)
sc=make([]int,2,10)
fmt.Println(sc) // [0 0]
fmt.Println(len(sc)) // len表示切片存储元素的长度
fmt.Println(cap(sc)) // cap表示最大可以存储的容量

(3) Traversée de tranches

sc:=[]int{1,2,3}
//普通for循环遍历
for i:=0;i<len(sc);i++{
	fmt.Println(s[i])
}
//for range遍历
for index,value:=range s{
	fmt.Println(index,value)
}

(4) méthode append()

La fonction intégrée du langage Go append() peut ajouter dynamiquement des éléments à une tranche. Vous pouvez ajouter un élément à la fois, plusieurs éléments ou des éléments d'une autre tranche (suivi de...).

var s1 []int  //定义切片s1
s1 = append(s1,1)  //在切片s1后面添加一个1的元素
s1 = append(s1,2,3,4) //在切片s1后面继续添加2,3,4
s2:=[]int{5,6,7}  //定义切片s2
s1 = append(s1,s2) //把切片s2中的元素追加到切片s1中

(5) méthode de copie

La fonction copy() intégrée dans le langage Go peut copier rapidement les données d'une tranche dans un autre espace de tranche. Le format d'utilisation de la fonction copy() est le suivant :

a:=[]int{1,2,3,4,5}
b:=make([]int,5,5)
copy(b,a) //把a切片中的元素copy到b切片中的元素
fmt.Println(b) //[1,2,3,4,5]
b[0]=1000
fmt.Println(b) // [1000,2,3,4,5]

ici Une chose à noter est qu'il existe un tel problème dans le développement réel

a := []int{1, 2, 3, 4, 5}
b := a
fmt.Println(a) //[1 2 3 4 5]
fmt.Println(b) //[1 2 3 4 5]
b[0] = 1000
fmt.Println(a) //[1000 2 3 4 5]
fmt.Println(b) //[1000 2 3 4 5]
/*
由于切片是引用类型，所以a和b其实都指向了同一块内存地址。
修改b的同时a的值也会发生变化。
*/

(6) Supprimer intelligemment des éléments dans la tranche

Il n'y a pas de méthode spéciale pour supprimer des éléments de tranche dans le langage Go. la tranche elle-même Propriété pour supprimer des éléments. Le code est le suivant :

// 从切片中删除元素
a := []int{30, 31, 32, 33, 34, 35, 36, 37}
// 要删除索引为2的元素
a = append(a[:2], a[3:]...)
fmt.Println(a) //[30 31 33 34 35 36 37]
/*
总结一下就是：要从切片a中删除索引为index的元素，
操作方法是a = append(a[:index], a[index+1:]...)
*/

Pour plus de connaissances sur la programmation, veuillez visiter :

Vidéo de programmation ! !

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!