Utilisation des tranches de Golang

Golang est un langage de programmation open source largement utilisé dans les domaines d'Internet et du Big Data depuis sa sortie en 2007. Parmi eux, slice (slice), en tant que fonctionnalité de tableau dynamique, est devenue l'une des structures de données les plus pratiques de Golang.

Cet article présentera en détail la définition, la création, l'interception, l'expansion et l'utilisation des tranches dans Golang, ainsi que la différence avec les tableaux.

1. Définition de slice

Slice dans Golang est une structure de données de type référence. Il s'agit d'une encapsulation du tableau sous-jacent et contient des informations associées telles que la référence, la longueur et la capacité du tableau sous-jacent.

Le format de définition d'une tranche est : var name []Type, où name est le nom de la tranche et Type est le type de l'élément slice.

Par exemple :

var s []int // Définir une tranche vide de type int
var a []string // Définir une tranche vide de type string

2. Création de tranches

Les tranches peuvent être effectuées via la fonction make crée. Le format de la fonction make est make([]Type, length,capacité), où Type est le type de l'élément slice, length est la longueur de la tranche et capacité est la capacité de la tranche.

Par exemple :

s := make([]int, 3, 5) // Crée une tranche de type int d'une longueur de 3 et d'une capacité de 5
a := make([]string, 2) / / Créer une tranche de type String de longueur 2 et de capacité 2

A noter que si la capacité n'est pas précisée, la capacité de la tranche créée sera égale à sa longueur, soit : make([]Type, length) .

De plus, des tranches peuvent également être créées via des tableaux. Par exemple :

arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:3] // Crée une tranche de l'index 1 à l'index 2 dans le tableau sous-jacent

3. Interception de tranches

Une tranche peut être interceptée pour obtenir une nouvelle tranche. Le format d'interception est nom[début:fin], où début représente l'indice de début et fin représente l'indice de fin (à l'exclusion de la fin elle-même).

Il convient de noter que la plage de valeurs de début et de fin est comprise entre [0, len(name)] et start≤end.

Par exemple :

s := make([]int, 5) // Crée une tranche de type int d'une longueur de 5
s1 := s[1:3] // Passe de l'indice 1 à l'indice 2 Découpage

De plus, vous pouvez également omettre l'un ou les deux début ou fin, de sorte que la tranche sélectionne la valeur maximale ou minimale comme début ou fin correspondant par défaut.

Par exemple :

s := make([]int, 5) // Crée une tranche de type int d'une longueur de 5
s1 := s[:3] // Récupère la tranche de l'index 0 à l'index 2
s2 := s[2:] // Récupère la tranche de l'indice 2 à l'indice 4
s3 := s[:] // Récupère la tranche entière

4. Expansion de la tranche

L'expansion de la tranche est basé sur l'original Lorsque la longueur de la tranche n'est pas suffisante, vous devez augmenter la capacité de la tranche, rouvrir un tableau sous-jacent plus grand et copier les données du tableau d'origine vers le nouveau tableau sous-jacent.

Le mécanisme d'expansion des tranches dans Golang consiste d'abord à demander une mémoire contiguë avec une capacité plus grande que la tranche actuelle, puis à copier les données du tableau sous-jacent d'origine vers le nouveau tableau sous-jacent. Enfin, le tableau sous-jacent d'origine est libéré, permettant à la tranche d'origine de référencer le nouveau tableau sous-jacent.

Le processus d'expansion des tranches est implémenté en bas par la bibliothèque d'exécution. Cela explique également pourquoi lors de l'utilisation de tranches, vous devez utiliser la fonction make pour spécifier la capacité (lorsque la capacité est insuffisante, elle sera étendue), ou pour l'ajuster dans le cadre de la tranche. Faites une déclaration.

Il est à noter que lorsqu'une tranche est agrandie, un espace mémoire sera alloué. Si les éléments de la tranche ne sont plus utiles, il est recommandé d'éviter de conserver ces éléments inutiles dans la tranche, qui occuperont trop de mémoire. .

5. La différence entre les tranches et les tableaux

Dans Golang, les tableaux et les tranches sont deux types de données différents. D'une part, un tableau est un conteneur de longueur fixe qui stocke des éléments du même type, tandis qu'une tranche est un tableau dynamique (conteneur dynamique) d'autre part, lorsqu'un tableau est utilisé, sa longueur est déjà déterminée ; lorsqu'elle est définie, et La longueur de la tranche peut être modifiée dynamiquement au moment de l'exécution ;

Pour les tableaux, la longueur est un composant du type de tableau et ne peut pas être modifiée, et lors de l'utilisation d'un tableau, la longueur du tableau doit être clairement donné. Dans de nombreux cas, l'utilisation de tableaux peut entraîner de nombreux inconvénients, par exemple lorsqu'une grande quantité de données doit être traitée, le tableau peut occuper trop d'espace mémoire et provoquer le blocage du programme.

D'un autre côté, les tranches sont une structure de données très utile. En raison de sa nature dynamiquement évolutive, le découpage peut bien surmonter l'inconvénient de la longueur fixe d'un tableau et constitue l'un des types de données préférés lorsqu'il s'agit de collections de données de taille variable. Lors de son utilisation, nous pouvons d'abord déclarer une tranche vide, puis augmenter dynamiquement sa longueur en fonction des besoins réels.

Conclusion

Cet article présente principalement l'utilisation courante des tranches dans Golang telles que la définition, la création, l'interception, l'expansion et la différence avec les tableaux. En tant que l'une des structures de données puissantes de Golang, le découpage peut nous aider à traiter rapidement et facilement des collections de données de taille variable. Maîtriser la méthode de fonctionnement du découpage nous permet d'écrire des programmes Golang plus efficacement.

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!