La slice (tranche) est un type de données moins courant dans d'autres langages. Elle est utilisée la plupart du temps à la place des tableaux, car elle est flexible, vous pouvez modifier, augmenter sa taille.

Parlons donc des tranches et de la façon dont elles sont définies. En gros, une tranche est une fenêtre (une vue, un sous ensemble) d'un tableau sous-jacent.

Ainsi, pour chaque tranche, il y aura un tableau sous-jacent qui servira de base à la tranche. La tranche n'en est qu'une partie (une fenêtre sur le tableau), un morceau.

Donc, vous avez un long tableau de 100 éléments, la tranche peut-être juste les éléments d'index trois, quatre et cinq, ou les éléments cinq, six, sept, huit et neuf. Voila pour l' essentiel ce qu'est une tranche : une fenêtre sur un tableau éventuellement plus grand.

Le tableau n'est pas nécessairement plus grand, il peut avoir la même taille que la tranche. Ensuite, la tranche peut avoir accès à l'ensemble du tableau, mais le tableau peut être beaucoup plus grand que la tranche et la tranche peut être simplement une fenêtre plus petite sur celui-ci.

Les tranches peuvent donc avoir une taille variable, pouvant aller jusqu'à la taille du tableau. C'est une chose très intéressante avec les tranches, vous pouvez augmenter la taille de la tranche. Un tableau est un objet de taille fixe.

Par exemple si j'ai un tableau de 100 éléments et que j'ai une tranche de taille 10, qui sur ce tableau correspond aux 10 premiers éléments. Je peux augmenter la taille de la tranche à 20, elle intégrera les 10 éléments suivants dans le tableau, puis je peux augmenter jusqu'à 30 et inclure ainsi les 10 éléments suivants du tableau.

Vous pouvez augmenter la taille de la tranche, ce qui n'est pas le cas pour un tableau.

Chaque tranche possède essentiellement trois propriétés.

La première est le pointeur qui indique le début de la tranche. Ainsi, chaque tranche, puisqu'il s'agit d'une fenêtre sur un tableau, doit pointer vers un élément du tableau qui est le premier élément inclus dans la tranche. C'est le pointeur.

La deuxième propriété d'une tranche, c'est sa longueur, c'est le nombre d'éléments qu'elle contient.

La troisième est la capacité. La capacité est donc le nombre maximum d'éléments dans la tranche. Cela est défini en regardant le pointeur qui est le début de la tranche et en regardant la différence entre celui-ci et la taille et la distance jusqu'à la fin de l'ensemble du tableau. Car pour une tranche, la taille peut être augmentée jusqu'à la limite de la taille totale du tableau.

Par exemple, avec tableau de taille 100, vous avez une tranche de taille 10. Vous pouvez augmenter la taille de cette tranche. Disons que la tranche commence juste au début du tableau, vous pouvez augmenter la taille de la tranche jusqu'à 100, si vous le souhaitez. Elle a donc une capacité de 100.

Supposons que vous ayez un tableau de taille 100 mais que cette tranche commence à l'index de tableau 10, alors elle ne peut être augmentée que jusqu'à une taille de 90 éléments, car après, vous atteignez la fin du tableau. La capacité de cette tranche est donc plus petite.

hello_slice.go

package main
 
import "fmt"
 
var arr = [...]string {"a", "b", "c", "d", "e", "f", "g"}
 
func main(){
 
   s1 := arr[1:3]
   s2 := arr[2:5]
 
   fmt.Printf("%s %s", s1, s2 )
}

Nous commençons par définir le tableau sous-jacent avec une définition littérale, il contient des chaînes de caractères d'un seul caractère “a”, “b”, “c”, “d”, “e”, “f” et “g”. C'est un tableau, le tableau de chaînes de caractères.

Dans la fonction main, nous avons défini deux tranches sur ce tableau : s1 et s2. Nous utilisons la notation entre crochets, nous utilisons : à l'intérieur des crochets pour séparer le début et la fin de la tranche. La valeur 1 est le pointeur vers le premier élément du tableau, qui se trouve à l'intérieur de la tranche, et la valeur 3 est l'index juste après la fin de la tranche. Donc, cette tranche, s1, inclut les éléments du tableau 1 et 2 mais pas 3. Ainsi, le deuxième chiffre après les deux points est juste après la fin.

Maintenant, si nous regardons s2, la slice commence à 2. Elle comprend les éléments 3 et 4, mais n' inclut pas 5.

Le schéma ci-dessus représente le tableau entier. Ensuite, en rouge, on a entouré s1 et s2. Donc, s1 inclut les index 1 et 2 et s2 inclut les index 2, 3 et 4.

Remarquez que ces deux tranches se chevauchent, et c'est normal. Si vous regardez s1 et s2, ils incluent la valeur d'index 2 du tableau sous-jacent, ça ne pose pas de problème.

Les tranches peuvent se chevaucher et faire référence aux mêmes éléments à l'intérieur du tableau sous-jacent.

Il existe deux fonctions len() et cap(), qui renvoient respectivement la longueur et la capacité d'une tranche.

a1 := [3]string {"a", "b", "c"}
 
sli1 := a1[0:1]
 
fmt.Printf( len(sli1), cap(sli1) )

Nous avons donc ci-dessus un tableau a1, qui compte trois éléments : “a”, “b”, “c”. Nous définissons une tranche, sli1 : cette tranche inclut l'index 0 mais pas l'index 1 du tableau. Sa longueur est en fait d'un élément, celui d'index 0 du tableau (“a”).

Nous affichons ensuite la longueur et la capacité : cette instruction affichera “ 1 3 ”. La longueur de la slice est de 1 (un seul élément d'index 0), mais sa capacité est toujours de 3, car sa taille pourrait augmenter jusqu'à la fin du tableau. Puisque le tableau contient 3 éléments, et que nous commençons la tranche au début à l'index 0 du tableau, nous pourrions passer par les indices 0, 1 et 2 et la longueur de la tranche pourrait être jusqu'à 3 éléments. Sa capacité est donc de 3.

Lorsque vous écrivez dans une slice, dans un élément d'une tranche, vous écrivez dans le tableau sous-jacent.

Les tranches qui se chevauchent peuvent faire référence aux mêmes éléments du tableau. Si vous modifiez une tranche, vous pouvez modifier le tableau sous-jacent et vous pouvez modifier n'importe quelle tranche qui y accède également, si elle inclut également cet élément du tableau.

Comme l'illustre le schéma ci-dessus, nous avons deux tranches s1 et s2. L'élément d'index 2, avec la lettre de la chaîne “c” est inclut en fait dans s1 et s2.

fmt.Printf( s1[1] )
fmt.Printf( s2[0] )

Ces deux instructions afficheront donc la même chose : la lettre “c”. Ils font tous deux référence au même élément du tableau sous-jacent.

Nous avons vu les définitions littérales de tableaux, vous pouvez également avoir des définition littérales pour les slices. On peut ainsi initialiser la slice de la même manière que pour les tableaux.

Chaque tranche doit avoir un tableau sous-jacent. Ainsi, lorsque vous initialisez une slice, cela signifie que vous créez un tableau. Le tableau sous-jacent est créé et la tranche couvre simplement l'ensemble du tableau.

Ainsi, lorsque vous utilisez une déclaration littérale de slice pour définir une tranche, cela crée en fait un tableau sous-jacent et une tranche qui référence l'ensemble du tableau. La longueur et la capacité de la tranche sont alors les mêmes.

Avec la déclaration littérale de slice, le pointeur sera positionné au début du tableau et la longueur de la slice sera la longueur du tableau, sa capacité sera également la longueur du tableau.

Avec une définition de slice littérale, la slice pointe vers l'ensemble du tableau sous-jacent.

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

Dans l'exemple ci-dessus nous utilisons une définition littérale de slice. Vous savez que c'est une définition littérale de slice parce que vous pouvez voir que les crochets sont vides. Normalement, entre crochets, vous mettez la longueur ou … s'il s'agit d'un tableau. Mais dans ce cas, nous n'avons rien mis entre crochets, le compilateur déduit que c'est une slice, crée le tableau sous-jacent, puis il fait pointer la slice sur l'ensemble du tableau.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷