Aller - Tranches

Go Slice est une abstraction sur Go Array. Go Array vous permet de définir des variables pouvant contenir plusieurs éléments de données du même type, mais il ne fournit aucune méthode intégrée pour augmenter sa taille de manière dynamique ou obtenir un sous-tableau qui lui est propre. Les tranches surmontent cette limitation. Il fournit de nombreuses fonctions utilitaires requises sur Array et est largement utilisé dans la programmation Go.

Définition d'une tranche

Pour définir une tranche, vous pouvez la déclarer en tant que tableau sans spécifier sa taille. Vous pouvez également utilisermake fonction pour créer une tranche.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

Fonctions len () et cap ()

Une tranche est une abstraction sur un tableau. Il utilise en fait des tableaux comme structure sous-jacente. lelen() function renvoie les éléments présents dans la tranche où cap()La fonction renvoie la capacité de la tranche (c'est-à-dire le nombre d'éléments qu'elle peut contenir). L'exemple suivant explique l'utilisation de slice -

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Nil tranche

Si une tranche est déclarée sans entrées, alors par défaut, elle est initialisée à nil. Sa longueur et sa capacité sont nulles. Par exemple -

package main

import "fmt"

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Slice permet de spécifier la limite inférieure et la limite supérieure pour en obtenir la sous-tranche en utilisant[lower-bound:upper-bound]. Par exemple -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

On peut augmenter la capacité d'une tranche en utilisant le append()fonction. En utilisantcopy()fonction, le contenu d'une tranche source est copié dans une tranche de destination. Par exemple -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]