Golang Slice

Cet article plongera profondément dans le travail avec des tranches dans le langage de programmation Go.

Nous connaissons tous les tableaux, soit en Go, soit dans d'autres langages de programmation. Un tableau est une collection d'éléments d'un type de données connexes (selon). En Go, un tableau ne peut contenir que des éléments d'un type similaire. Les tableaux ont une longueur fixe et ne peuvent pas grandir ou rétrécir une fois la taille définie.

Une tranche est une vue de taille dynamiquement des éléments d'un tableau. Une tranche est très flexible, vous permettant de le redimensionner. Cependant, le redimensionnement doit rester sous la capacité du tableau sous-jacent.

Déclarer une tranche

Nous pouvons déclarer une tranche en utilisant une syntaxe simple comme indiqué ci-dessous:

var slice_name [] data _type

Dans la syntaxe ci-dessus, nous commençons par spécifier le slice_name suivi d'une paire de crochets et du type de données pour la tranche.

Vous remarquerez que la déclaration de tranche est très similaire à celle d'un tableau. Cependant, nous ne spécifions pas de taille pour une tranche.

Créer Slice - Méthode 1

Il existe deux méthodes pour créer une tranche dans Go. Le premier consiste à utiliser le format littéral. Ceci est étroitement similaire à celui illustré dans la syntaxe ci-dessus.

Par exemple, le code ci-dessous crée une tranche appelée my_slice:

package principal
Importer "FMT"
funcmain ()
var my_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println (my_slice)

L'exemple ci-dessus crée une tranche de type int avec des valeurs par défaut. Si vous ne souhaitez pas utiliser la méthode VAR de la déclaration variable, vous pouvez utiliser la syntaxe ci-dessous:

my_slice: = [] int 1,2,3,4,5,6

La méthode ci-dessus est connue sous le nom de tranche littérale.

Créer Slice - Méthode 2

La deuxième méthode pour créer une tranche en go consiste à utiliser la fonction de faire.

La syntaxe est comme:

func make ([] t, len, cap) [] t

La fonction prend un type de données, une longueur et une capacité dans ce cas. La fonction allouera un tableau avec la taille spécifiée par le paramètre de capacité. La fonction renvoie une tranche faisant référence à ce tableau.

Pour le voir dans la pratique, voir ci-dessous:

slice_var: = make ([] int, 10)
fmt.Println (slice_var)

Cet exemple déclare une tranche de taille 10 et de type int. La sortie résultante est une tranche de 0 valeurs.

[0 0 0 0 0 0 0 0 0 0 0]

Vous pouvez attribuer les valeurs à la tranche en utilisant la notation d'index.

Pour attribuer une valeur à l'index 1, nous pouvons faire:

slice_var [0] = 10
fmt.Println (slice_var)

Le code ci-dessus doit retourner:

[10 0 0 0 0 0 0 0 0 0 0]

Remarque L'élément de l'index 0 est mis à jour pour refléter la nouvelle valeur.

Trancher les propriétés

Il y a deux propriétés importantes d'une tranche avec laquelle vous devriez être familier. La longueur et la capacité.

La durée de la tranche se réfère au nombre total d'éléments détenus par la tranche, tandis que la capacité se réfère au nombre d'éléments définis par le tableau sous-jacent. Ceci est compté à partir du premier élément de la tranche.

Pour obtenir la longueur et la capacité d'une tranche, vous pouvez utiliser les méthodes Len () et Cap (), respectivement.

Un exemple est comme démontré ci-dessous:

package principal
Importer "FMT"
funcmain ()
varmy_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println ("longueur:", Len (my_slice))
fmt.Println ("Capacité:", cap (my_slice))

L'exemple de code ci-dessus doit renvoyer la longueur et la capacité de la tranche comme:

Ength: 6
Capacité: 6

GO INDEX SUCTICATION

Saviez-vous que nous pouvons former une tranche à partir de tranches existantes?

Nous pouvons y parvenir en spécifiant un indice lié avec une limite faible et élevée. Par exemple, pour créer une nouvelle tranche avec des éléments de l'index 1 à 5:

new_slice: = my_slice [1: 5]
fmt.Println (new_slice)
La tranche résultante devient:
[2 3 4 5]

Itération

Nous pouvons itérer sur un tableau en utilisant le classique pour une boucle.

Par exemple:

package principal
Importer "FMT"
funcmain ()
varmy_slice = [] String "Python", "JavaScript", "Go", "Rust", "Dart"
fori, item: = rangemy_slice
fmt.Println (i, article)

Dans l'exemple ci-dessus, nous utilisons une boucle pour la boucle et une instruction de plage pour itérer sur l'index et l'élément de la tranche. La sortie résultante:

0 Python
1 javascript
2 aller
3 rouille
4 fléchettes

Si vous ne souhaitez pas utiliser l'instruction Range pour boucler sur la tranche, vous pouvez utiliser la longueur de la tranche comme:

pour i: = 0; je < len(my_slice); i++
fmt.Println (my_slice [i])

L'exemple ci-dessus renverra une sortie similaire à celle de la construction de la plage.

Aller à l'élément de copie

La méthode de copie vous permet de copier des éléments d'une tranche à une autre. Considérez l'exemple ci-dessous:

funccopy_slice ()
Slice_1: = [] int 1, 2, 3, 4, 5
Slice_2: = [] int 6, 7, 8, 9, 10
new_slice: = copy (slice_1, slice_2)
fmt.Printf ("% d éléments copié", new_slice)

La fonction renverra le nombre total d'éléments copiés.

Tranche multidimensionnelle

Vous pouvez également créer une tranche multidimensionnelle. Cela signifie essentiellement une tranche de tranches. Un exemple est comme indiqué:

funcMulti_slice ()
multi_slice: = [] [] int
1, 2,
3, 4,
5, 6,
7, 8,

fmt.Println (multi_slice)

L'exemple ci-dessus devrait imprimer une tranche multidimensionnelle comme:

[[1 2] [3 4] [5 6] [7 8]]

Pour accéder aux éléments dans un tableau multidimensionnel, vous pouvez utiliser des index comme:

fmt.Println (multi_slice [0] [0])

La syntaxe ci-dessus renvoie le premier élément de la première tranche.

Conclusion

Ce guide vous aide avec les bases de travailler avec des tranches dans Go. Bien que nous ne puissions pas épuiser les tranches dans le cadre de ce tutoriel, cela devrait vous aider à démarrer.