Tranche du langage Go (Slice)
Les tranches du langage Go sont une abstraction des tableaux.
La longueur des tableaux Go ne peut pas être modifiée, donc dans certains scénarios, une telle collection n'est pas très adaptée. Go fournit un type intégré flexible et puissant : la tranche ("tableau dynamique"). Comparé aux tableaux, la longueur d'une tranche n'est pas fixe ; des éléments peuvent être ajoutés, et l'ajout peut augmenter la capacité de la tranche.
Définition des tranches
Vous pouvez déclarer un tableau dont la taille n'est pas spécifiée pour définir une tranche :
var identifier []type
Il n'est pas nécessaire de spécifier une longueur pour les tranches.
Ou utilisez la fonctionmake()pour créer une tranche :
var slice1 []type = make([]type, len) 也可以简写为 slice1 := make([]type, len)
Vous pouvez également spécifier la capacité, oùcapacityest un paramètre facultatif.
make([]T, length, capacity)
Ici, len est la longueur du tableau et aussi la longueur initiale de la tranche.
Initialisation des tranches
s :=[] int {1,2,3 }
Initialisez directement la tranche,[]Indique qu'il s'agit d'un type tranche,{1,2,3}Les valeurs d'initialisation sont, dans l'ordre :1,2,3, sacap=len=3。
s := arr[:]
Initialiser une slices, est une référence au tableau arr.
s := arr[startIndex:endIndex]
Créer une nouvelle slice à partir des éléments de arr de l'indice startIndex à endIndex-1.
s := arr[startIndex:]
Lorsque endIndex est défini par défaut, cela signifie jusqu'au dernier élément de arr.
s := arr[:endIndex]
Lorsque startIndex est défini par défaut, cela signifie commencer à partir du premier élément de arr.
s1 := s[startIndex:endIndex]
Initialiser la slice s1 à partir de la slice s.
s :=make([]int,len,cap)
Grâce à la fonction intégréemake(), initialiser une slice.s,[]intdésigne une slice dont le type d'élément est int.
Les fonctions len() et cap()
Les slices sont indexables, et leur longueur peut être obtenue par la méthode len().
Les slices fournissent la méthode cap() pour calculer la capacité, ce qui permet de mesurer la longueur maximale qu'une slice peut atteindre.
Voici des exemples concrets :
Exemple
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSlice(numbers)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
La sortie de l'exemple ci-dessus est :
len=3 cap=5 slice=[0 0 0]
Tranche vide (nil)
Avant qu'une tranche ne soit initialisée, elle vaut nil par défaut avec une longueur de 0, par exemple :
Exemple
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
if(numbers == nil){
fmt.Printf("La tranche est vide")
}
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
La sortie de l'exemple ci-dessus est :
len=0 cap=0 slice=[] 切片是空的
Découpage d'une tranche
Vous pouvez définir des limites inférieure et supérieure pour découper une tranche.[lower-bound:upper-bound], par exemple comme suit :
Exemple
import "fmt"
func main() {
/* Créer une tranche */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* Afficher la tranche d'origine */
fmt.Println("numbers ==", numbers)
/* Afficher la sous-tranche de l'indice 1 (inclus) à l'indice 4 (exclus) */
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* La borne inférieure par défaut est 0 */
fmt.Println("numbers[:3] ==", numbers[:3])
/* La borne supérieure par défaut est len(s) */
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* Afficher la sous-tranche de l'indice 0 (inclus) à l'indice 2 (exclus) */
number2 := numbers[:2]
printSlice(number2)
/* Afficher la sous-tranche de l'indice 2 (inclus) à l'indice 5 (exclus) */
number3 := numbers[2:5]
printSlice(number3)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
La sortie de l'exécution du code ci-dessus est :
len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8] numbers == [0 1 2 3 4 5 6 7 8] numbers[1:4] == [1 2 3] numbers[:3] == [0 1 2] numbers[4:] == [4 5 6 7 8] len=0 cap=5 slice=[] len=2 cap=9 slice=[0 1] len=3 cap=7 slice=[2 3 4]
fonctions append() et copy()
Si vous voulez augmenter la capacité d'une slice, vous devez créer une nouvelle slice plus grande et copier le contenu de la slice d'origine dedans.
Le code suivant décrit la méthode copy pour copier des slices et la méthode append pour ajouter de nouveaux éléments à une slice.
Exemple
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
/* Permet d'ajouter à une slice vide */
numbers = append(numbers, 0)
printSlice(numbers)
/* Ajoute un élément à la slice */
numbers = append(numbers, 1)
printSlice(numbers)
/* Ajoute plusieurs éléments en même temps */
numbers = append(numbers, 2,3,4)
printSlice(numbers)
/* Crée la slice numbers1 avec deux fois la capacité de la slice précédente */
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* Copier le contenu de numbers dans numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
La sortie de l'exécution du code ci-dessus est :
len=0 cap=0 slice=[] len=1 cap=1 slice=[0] len=2 cap=2 slice=[0 1] len=5 cap=6 slice=[0 1 2 3 4] len=5 cap=12 slice=[0 1 2 3 4]autres extensions