Comment trancher en golang

Golang est un langage de programmation efficace, fortement typé et sécurisé contre la concurrence, qui est de plus en plus privilégié par les développeurs en raison de ses excellentes performances et de sa facilité d'utilisation. Slice est l'une des structures de données importantes de Golang. Il s'agit d'un tableau dynamique qui peut augmenter ou diminuer dynamiquement la longueur selon les besoins. C'est l'une des structures de données couramment utilisées dans Golang. Cet article présentera en détail comment utiliser le découpage Golang.

1. Définition des tranches

Dans Golang, utilisez la fonction make() pour créer des tranches La fonction make() s'utilise comme suit :

#🎜 🎜 #slice1 := make([]T, len, cap)

Parmi eux, T fait référence au type d'éléments dans la tranche, len fait référence à la longueur de la tranche et cap fait référence à la capacité de la tranche, c'est-à-dire la taille du tableau sous-jacent de la longueur de la tranche.

Par exemple, définissez une slice de type int d'une longueur de 3 et d'une capacité de 5. Le code est le suivant :

slice1 := make([]int, 3, 5)#🎜 🎜#

Le code ci-dessus créera une tranche contenant 3 éléments entiers et la longueur du tableau sous-jacent est de 5.

2. Opération de tranche

2.1 Traversée de tranche

Dans Golang, la traversée de tranche peut être implémentée en utilisant la boucle for et le mot-clé range.

1. Utilisez une boucle for

Lorsque vous utilisez une boucle for pour parcourir une tranche, vous pouvez utiliser la fonction len() pour obtenir la longueur de la tranche et utiliser le index pour accéder à chaque élément. Par exemple, définissez une slice de type int contenant 1 à 5, le code est le suivant :

slice1 := []int{1, 2, 3, 4, 5}

for i := 0 ; i < len(slice1); i++ {

fmt.Println(slice1[i])

}

Le code ci-dessus affichera chaque élément dans slice slice1.

2. Utilisez le mot-clé range

Utilisez le mot-clé range pour parcourir les tranches de manière plus concise. Par exemple, pour la tranche slice1 ci-dessus, vous pouvez utiliser le code suivant pour parcourir :

slice1 := []int{1, 2, 3, 4, 5}

for index, item := range slice1 {

fmt.Printf("Index: %d, Value: %d

", index, item)

}

Ce code affichera l'index et la valeur de chaque élément de la tranche. # 🎜🎜## 🎜🎜#2.2 Ajout de tranches

Les tranches peuvent stocker dynamiquement des données Vous pouvez utiliser la fonction append() pour ajouter des éléments à la tranche. définir une section contenant 1~ 3 tranches de type int, le code est le suivant :

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

Maintenant, nous avons besoin pour ajouter 4 et 5 aux éléments slice, vous pouvez utiliser la fonction append(), par exemple :

slice1 = append(slice1, 4, 5)

It Should Il convient de noter que lors de l'ajout d'éléments à la tranche, si la capacité du tableau sous-jacent est insuffisante, un tableau sous-jacent plus grand sera réaffecté et les éléments d'origine seront copiés dans le nouveau tableau sous-jacent. Par conséquent, vous devez faire attention à l'expansion. de la tranche. De manière générale, afin d'éviter une expansion fréquente, vous pouvez prérégler la longueur du tableau sous-jacent de la tranche

2.3 Interception de la tranche

In. En plus des éléments ajoutés, vous pouvez également intercepter la tranche pour la transformer en une nouvelle tranche. L'opération d'interception de tranche utilise l'opérateur de tranche [x:y], où x est la position de départ de l'interception (en comptant à partir de 0) et y. est la position finale de l'interception.

Par exemple, définissez une tranche de type int contenant 1 à 5. Le code est le suivant :

slice1 := []int{1. , 2, 3, 4, 5}

Pour intercepter Pour les trois premiers éléments de la slice, vous pouvez utiliser le code suivant :

slice2 := slice1[0: 3]

Le code ci-dessus renverra un fichier contenant les trois premiers éléments de la tranche tranche1 Tranche de l'élément tranche2

2.4 Copie de la tranche

. Utilisez la fonction copy() dans Golang pour copier une tranche dans une autre tranche. L'exemple est le suivant : #🎜 🎜#

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

slice2 := make([]int, len(slice1))

copy(slice2, slice1)#🎜🎜 #fmt.Println(slice2)

Le code ci-dessus créera une tranche slice2 avec le même longueur comme slice1 et copiez les éléments de slice1 vers slice2.

3. Problème d'expansion du découpage

Lors de l'ajout d'éléments, la capacité du tableau sous-jacent de la tranche peut être insuffisante et des opérations d'expansion se produiront à ce moment-là. L'expansion par découpage nécessite une réallocation de mémoire et la copie des éléments d'origine vers le nouveau tableau sous-jacent, ce qui est un processus qui prend du temps. Par conséquent, lors de la conception des tranches, la capacité de la tranche doit être prise en compte.

Dans Golang, vous pouvez utiliser la fonction cap() pour obtenir la capacité de la tranche. Si la capacité de la tranche est pleine, la mémoire doit être réaffectée pour doubler la longueur du tableau sous-jacent.

Par exemple, définissez une slice de type int d'une longueur de 2 et d'une capacité de 3. Le code est le suivant :

slice1 := make([]int, 2, 3)#🎜 🎜#

Maintenant, nous voulons ajouter 3 éléments à la tranche, ce qui peut être réalisé de la manière suivante :

for i := 3; = 5; i++ {

slice1 = append(slice1, i)
fmt.Println("Len:", len(slice1), ", Cap:", cap(slice1))

}

Le code ci-dessus affichera la longueur et la capacité de la tranche après chaque élément ajouté.

Il est à noter que l'opération d'expansion peut entraîner une modification de l'adresse du tableau sous-jacent de la tranche, il est donc nécessaire d'éviter d'utiliser un pointeur vers la tranche d'origine comme paramètre d'une fonction, ce qui pourrait causer des problèmes potentiels.

4. Conseils pour l'utilisation des slices

Lors de la conception de programmes Golang, le slicing est une structure de données très couramment utilisée :

.

• Lorsque vous utilisez des tranches dans une boucle, vous pouvez d'abord attribuer la tranche en dehors de la boucle. Cela peut éviter de réallouer la mémoire de la tranche à chaque itération et réduire la surcharge de mémoire.
• Lorsqu'une tranche est utilisée comme paramètre de fonction, elle peut être déclarée comme type de pointeur. Cela peut éviter de copier la tranche entière lorsque la fonction est appelée et réduire la consommation de mémoire.
• Dans Golang, vous pouvez utiliser la fonction append() pour ajouter des éléments à une tranche, mais si vous devez supprimer des éléments, vous devez utiliser les opérations de copie et d'interception de la tranche.

5. Résumé

Le découpage en Golang est une structure de données très couramment utilisée qui peut stocker dynamiquement des éléments et se développer automatiquement. Lorsque vous utilisez des tranches, vous devez faire attention à la capacité de la baie sous-jacente pour éviter des opérations d'expansion fréquentes.

Cet article présente la définition, le fonctionnement et les compétences d'utilisation du découpage. J'espère qu'il pourra être utile aux développeurs Golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!