Golang Array Ajout

Une tranche est une structure de données flexible et extensible utilisée pour stocker et gérer une collecte de données commandées. Ils sont très similaires aux tableaux avec une différence majeure: les tranches sont de longueur dynamique, vous permettant d'étendre ou de rétrécir leur longueur comme.

Semblable aux tableaux, nous utilisons des index pour accéder aux éléments dans une tranche. Ils ont également des propriétés de longueur et de capacité.

Dans ce guide, nous discuterons de la façon de travailler avec des tranches et comment ajouter ou supprimer les éléments d'une tranche comme vous le voyez bien.

Aller créer une tranche

Vous pouvez créer une tranche de manière similaire à ce que vous feriez lors de la création d'un tableau. Nous commençons par le nom du tableau, suivi d'une paire de crochets et du type de données.

Gardez à l'esprit qu'une tranche ne peut contenir que des éléments du même type.

Considérez l'exemple ci-dessous pour créer un tableau vide:

var slice_array [] chaîne

Pour créer une tranche avec des éléments, nous pouvons faire:

var slice_name: = [] string "element1", "element2", "element3",…

Tranche d'impression

Vous pouvez imprimer une tranche en utilisant le FMT.Méthode println. Par exemple:

package principal
Importer "FMT"
func main ()
my_slice: = [] String
"Winnie",
"Meule",
"Anna",
"Elsa",
"Olaf",

fmt.Println ("Slice:", my_slice)

L'exemple ci-dessus renvoie chaque élément de la tranche comme indiqué ci-dessous:

Slice: [Winnie Rick Anna Elsa Olaf]

Pour montrer la longueur de la tranche, vous pouvez utiliser la méthode Len ():

fmt.Println ("Lhenght:", Len (my_slice))

Un exemple de sortie est comme indiqué:

Lenght: 5

Vous pouvez également déterminer la capacité d'une tranche en utilisant la méthode CAP () comme indiqué:

fmt.Println ("Capacité:", cap (my_slice))

La sortie est comme indiqué:

Capacité: 5

La longueur du tableau fait référence au nombre total d'éléments d'un tableau détient. En revanche, la capacité se réfère au nombre d'éléments du tableau sous-jacent du premier élément de la tranche spécifiée.

Ajouter à la tranche

Comme mentionné, une tranche est de taille dynamique. Cela vous permet d'ajouter ou de supprimer des éléments comme vous le voyez.

Pour ajouter un élément à une tranche en Go, nous pouvons utiliser la méthode annexée ().

Un exemple est comme indiqué:

my_slice: = [] String
"Winnie",
"Meule",
"Anna",
"Elsa",
"Olaf",

my_slice = annexation (my_slice, "David",)

La méthode annexée () prend le nom de la tranche et le nouvel élément à ajouter. Dans l'exemple ci-dessus, nous ajoutons l'élément «David» à la tranche «my_slice».

La tranche résultante est comme indiqué:

Slice: [Winnie Rick Anna Elsa Olaf David]

Vous pouvez ajouter plusieurs éléments à l'aide de la fonction annexée () comme:

my_slice = annexation (my_slice, "David", "Mary")

Remarque: une tranche maintiendra toujours l'ordre des éléments, et les nouveaux éléments sont annexés à la fin de la tranche.

Vous pouvez également ajouter une tranche à une autre tranche comme indiqué:

my_slice: = [] String
"Winnie",
"Meule",
"Anna",
"Elsa",
"Olaf",

second_slice: = [] String
"Emma",
"Matthieu",

my_slice = append (my_slice, second_slice…)
fmt.Println ("Slice:", my_slice)

Nous ajoutons une tranche à une tranche existante à l'aide de la méthode annexée () dans l'exemple ci-dessus.

Faites attention à l'opérateur «…» dans la deuxième tranche. Cela indique au compilateur que le deuxième argument doit être étendu et chaque élément est passé à la fonction d'ajout en tant que composants individuels. Ceci est connu comme un paramètre variatique.

La tranche résultante comme:

Slice: [Winnie Rick Anna Elsa Olaf Emma Matthew]

Aller à la tranche

Vous pouvez utiliser une boucle pour itérer sur les éléments d'une tranche. Un exemple est un montré ci-dessous:

pour index, élément: = range my_slice
fmt.Printf ("élément à index% d =>% s \ n", index, élément)

Dans l'exemple ci-dessus, nous utilisons une plage de boucle pour itérer sur chaque élément de la tranche. Nous utilisons l'index pour récupérer l'élément comme indiqué dans la sortie ci-dessous:

Élément à l'index 0 => winnie
Élément à l'index 1 => Rick
Élément à l'index 2 => Anna
Élément à l'index 3 => elsa
Élément à l'index 4 => olaf
Élément à l'index 5 => David
Élément à l'index 6 => Mary

Conclusion

Ce guide a couvert les bases du travail avec des tranches dans le langage de programmation Go. En utilisant des tranches, vous pouvez introduire une flexibilité à vos programmes.

Merci d'avoir lu!