Introduction détaillée aux principes de mise en œuvre et à l'utilisation courante de Golang Slice

Le langage Slice in Go est une séquence dynamique basée sur l'implémentation d'un tableau, qui peut augmenter ou diminuer dynamiquement sa taille au moment de l'exécution et prend en charge les opérations courantes sur les données découpées, telles que l'ajout, l'insertion, l'épissage, la copie et le découpage. Cet article présentera en détail les principes de mise en œuvre et l’utilisation courante de slice.

1. Structure de données de tranche

Dans le langage Go, la structure de données de tranche se compose de trois parties : le pointeur vers le tableau sous-jacent, la longueur de la tranche et la capacité de la tranche. La définition spécifique est la suivante :

type slice struct {

ptr *int  // 指向 slice 引用的底层数组
len int   // slice 的长度
cap int   // slice 的容量

}

Parmi eux, le pointeur ptr pointe vers la position de départ du tableau sous-jacent, len représente la longueur de la tranche et cap représente la capacité du tranche. La longueur de la tranche représente le nombre d'éléments actuellement stockés dans la tranche, et la capacité de la tranche représente le nombre d'éléments pouvant être stockés dans le tableau sous-jacent actuel.

2. Initialisation de slice

Dans le langage Go, il existe deux façons de créer une tranche : utiliser la fonction intégrée make() pour créer une tranche, ou utiliser un littéral de tranche pour déclarer et initialiser directement une tranche.

Utilisez la fonction intégrée make() pour créer une tranche :

slice := make([]type, length,capacité)

La fonction make() créera un tableau sous-jacent et renverra une tranche pointant vers le array, avec ses paramètres représentent respectivement le type d'élément de tranche, la longueur de la tranche et la capacité de la tranche. Parmi eux, la capacité de la tranche peut être omise, elle aura par défaut la même longueur, indiquant que la tranche n'a pas d'espace libre.

Utilisez des littéraux de tranche pour déclarer et initialiser des tranches :

slice := []type{elements}

Les tranches créées par des littéraux de tranche n'ont pas besoin de spécifier la longueur et la capacité. Le langage Go les calculera automatiquement en fonction du nombre. d’éléments dans la tranche. La longueur et la capacité de la tranche.

3. Opérations de base de slice

1. Obtenez les éléments dans la tranche

Utilisez l'opérateur d'indice [] pour obtenir l'élément avec l'indice spécifié dans la tranche. L'indice commence à 0 et peut atteindre un maximum de len. -1. Par exemple :

slice := []int{1, 2, 3}
fmt.Println(slice[0]) // Sortie : 1

2 Le parcours de tranche

peut être parcouru à l'aide du mot-clé for loop et range. éléments dans la tranche. Par exemple :

slice := []int{1, 2, 3}
pour index, value := range slice {

fmt.Printf("index:%d value:%d\n", index, value)

}

3. Ajouter des éléments à slice

Utilisez la fonction intégrée append(. ) Ajoutez des éléments à la tranche. La fonction append() renvoie une nouvelle tranche et la tranche d'origine ne sera pas modifiée. Par exemple :

slice1 := []int{1, 2, 3}
slice2 := append(slice1, 4, 5)
fmt.Println(slice1) // Sortie : [1 2 3]
fmt.Println ( slice2) // Sortie : [1 2 3 4 5]

4. Copier la tranche

Utilisez la fonction intégrée copy() pour copier une tranche dans une autre tranche. Par exemple :

slice1 := []int{1, 2, 3}
slice2 := make([]int, len(slice1))
copy(slice2, slice1)
fmt.Println(slice2) // Sortie : [1 2 3]

5. Slice

Utilisez l'opérateur slice [:] pour découper la tranche à partir de l'index spécifié. Le résultat du découpage est une nouvelle tranche et la tranche d’origine ne sera pas modifiée. Par exemple :

slice1 := []int{1, 2, 3}
slice2 := slice1[1:]
fmt.Println(slice2) // Sortie : [2 3]

4.

Le langage Slice in Go est une séquence dynamique implémentée à base de tableaux. Lorsqu'une tranche est créée, le langage Go crée un tableau et pointe le ptr de la tranche vers la position de départ du tableau. Initialement, la longueur de la tranche est 0 et la capacité est la longueur du tableau sous-jacent. Lorsque append() est appelé pour ajouter un élément, le langage Go vérifiera si la tranche actuelle a suffisamment de capacité pour stocker le nouvel élément. Si cela est suffisant, il ajoutera le nouvel élément directement à la fin de la tranche actuelle si ; c'est insuffisant, cela réaffectera un tableau plus grand et copiera les éléments de la tranche actuelle dans le nouveau tableau, puis ajoutera les nouveaux éléments. Par conséquent, si la capacité de la tranche est insuffisante, le tableau sous-jacent changera, ce qui affectera toutes les tranches qui référencent le tableau.

Lors du découpage d'une tranche, le langage Go créera une nouvelle tranche et pointera ptr vers la position de départ de la tranche dans le tableau d'origine. La longueur et la capacité de la tranche sont déterminées par l'opérateur de tranche [:] et les paramètres lors de la création de la tranche. Par conséquent, lors du découpage, un nouveau tableau n’est pas créé, mais le tableau d’origine est réutilisé.

5. Résumé

Cet article présente les principes d'implémentation et l'utilisation courante de slice en langage Go. Slice est une structure de données importante pour réaliser des séquences dynamiques en langage Go. Son utilisation est flexible et efficace, et elle est particulièrement pratique pour le traitement. données de longueur variable. Maîtrisant les compétences d'utilisation et les principes de mise en œuvre de slice, vous pouvez écrire des programmes Go plus efficacement et optimiser les performances du code.

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!