Aller à la tranche de langue (Slice)

Les tranches de langage Go sont une abstraction de tableaux.

La longueur des tableaux Go ne peut pas être modifiée. Dans certains scénarios, de telles collections ne conviennent pas. Go fournit une tranche de type intégrée flexible et puissante ("tableau dynamique"). La tranche n'est pas fixe. Des éléments peuvent être ajoutés, ce qui peut augmenter la capacité de la tranche.

Définition de tranches

Vous pouvez déclarer un tableau de taille non spécifiée pour définir une tranche :

var identifier []type

Les tranches n'ont pas besoin de spécifier la longueur.

Ou utilisez la fonction make() pour créer une tranche :

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

也可以简写为

slice1 := make([]type, len)

Vous pouvez également spécifier la capacité, où la capacité est un paramètre facultatif.

make([]T, length, capacity)

Ici len est la longueur du tableau et est également la longueur initiale de la tranche.

Initialisation de la tranche

s :=[] int {1,2,3 }

Initialisez directement la tranche, [] indique le type de tranche, la valeur d'initialisation {1,2,3} est 1,2,3 dans l'ordre. 3

s := arr[:]

Initialiser slice s, qui est une référence au tableau arr

s := arr[startIndex:endIndex]

Créer les éléments dans arr de l'indice startIndex à endIndex-1 en tant que nouvelle tranche

s := arr[startIndex:]

Manquant Lorsque endIndex est omis, il représentera jusqu'au dernier élément de arr

s := arr[:endIndex]

Lorsque startIndex est par défaut, il représentera à partir du premier élément de arr

s1 := s[startIndex:endIndex]

Initialiser la tranche s1 jusqu'à slice s

s :=make([]int,len,cap)

Initialisez slice s via la fonction intégrée make(), []int identifie la tranche dont le type d'élément est int

fonctions len() et cap()

slice est indexable et la longueur peut être obtenue par la méthode len().

Les tranches fournissent une méthode de calcul de la capacité. cap() peut mesurer la longueur d'une tranche.

Ce qui suit est un exemple spécifique :

package main

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

Le résultat de sortie de l'exemple ci-dessus est :

len=3 cap=5 slice=[0 0 0]

Tranche vide (nil)

Une tranche dans le futur Avant l'initialisation, la valeur par défaut est nulle et la longueur est 0. L'exemple est le suivant :

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Le résultat de sortie de l'exemple ci-dessus est :

len=0 cap=0 slice=[]
切片是空的

L'interception de tranche

peut être définie en définissant la limite inférieure et la limite supérieure est utilisée pour définir la tranche d'interception [lower-bound:upper-bound] L'exemple est le suivant :

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Le résultat 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 nous voulons augmenter la capacité de la tranche , nous devons créer une nouvelle tranche plus grande et copier le contenu de la tranche d'origine.

Le code suivant décrit la méthode de copie à partir d'une tranche et la méthode d'append pour ajouter de nouveaux éléments à la tranche.

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}