Analyse approfondie du fonctionnement du découpage de la langue Go

En tant que langage de programmation rapide et efficace, le langage Go a naturellement attiré l'amour de nombreux développeurs. Parmi elles, slice est l'une des structures de données les plus couramment utilisées dans le langage Go. Elle est flexible et efficace et est largement utilisée pour stocker des collections de données de longueur dynamique. Cet article fournira une analyse approfondie du fonctionnement du découpage du langage Go et l'expliquera à travers des exemples de code spécifiques.

1. Définition et déclaration des tranches

En langage Go, une tranche est une structure de données légère composée de trois parties : un pointeur vers le tableau sous-jacent, la longueur de la tranche et la capacité de la tranche. La forme de déclaration d'une tranche est :

var slice []int

Ou utilisez la fonction make pour créer une tranche :

slice := make([]int, 0, 5)

Parmi eux, le premier paramètre de la fonction make est le type de la tranche, le deuxième paramètre est la longueur de la tranche , et le troisième paramètre est la capacité de la tranche.

2. Le tableau sous-jacent de la tranche

Le tableau sous-jacent de la tranche est l'espace de stockage de données réel référencé par la tranche. Lorsque la tranche est créée, un espace mémoire continu sera automatiquement alloué pour le stockage des données. Lorsqu'une tranche effectue une opération d'ajout, si les nouvelles données dépassent la capacité de la tranche, le système alloue automatiquement un tableau sous-jacent plus grand et copie les données d'origine dans le nouveau tableau sous-jacent.

slice1 := make([]int, 3, 5)
slice2 := append(slice1, 4)

Dans le code ci-dessus, le tableau sous-jacent de slice1 a une longueur de 5 et une capacité de 5. Lorsque l'opération d'ajout est effectuée, le système réaffectera automatiquement un tableau sous-jacent et copiera les données d'origine dans le nouveau tableau sous-jacent. Le tableau sous-jacent référencé par slice2 a une longueur de 6 et une capacité de 10.

3. Comment fonctionne le découpage

Le principe de fonctionnement du découpage peut être expliqué par l'exemple de code suivant :

package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[1:3] // 切片包含array[1]和array[2]

    fmt.Printf("数组array：%v
", array)
    fmt.Printf("切片slice：%v
", slice)
    fmt.Printf("切片长度：%d
", len(slice))
    fmt.Printf("切片容量：%d
", cap(slice))
}

Les résultats d'exécution sont les suivants :

数组array：[1 2 3 4 5]
切片slice：[2 3]
切片长度：2
切片容量：4

Comme le montrent les résultats, la tranche slice contient le tableau. indice 1 et L'élément de 2 a une longueur de 2 et une capacité de 4. La longueur de la tranche représente le nombre d'éléments réellement stockés dans la tranche, et la capacité représente le nombre d'éléments dans la tranche depuis la position actuelle jusqu'à la fin du tableau sous-jacent.

4. Caractéristiques des tranches

Les tranches sont des types de référence et les opérations sur les tranches affecteront le tableau sous-jacent et les autres tranches. Lorsque plusieurs tranches font référence conjointement à un tableau sous-jacent, si les éléments d’une tranche changent, les autres tranches partageant le tableau sous-jacent seront également affectées.

package main

import "fmt"

func main() {
    array := [3]int{1, 2, 3}
    slice1 := array[:] // slice1引用整个数组
    slice2 := array[1:] // slice2引用数组从索引1开始的子数组

    slice1[0] = 100
    fmt.Println(array) // [100 2 3]
    fmt.Println(slice2) // [2 3]
}

Dans le code ci-dessus, la modification du premier élément de slice1 à 100 entraînera également la modification du premier élément du tableau sous-jacent. Étant donné que slice2 partage le tableau sous-jacent, slice2 est également affecté.

5. Mécanisme d'extension de tranche

Lorsque la capacité de la tranche n'est pas suffisante pour stocker de nouvelles données, le système alloue automatiquement une capacité plus grande à la tranche. Dans des circonstances normales, la nouvelle capacité est le double de la capacité d'origine, mais si la capacité d'origine est inférieure à 1 024, la nouvelle capacité est de 1,25 fois la capacité d'origine.

slice := make([]int, 3, 5)
fmt.Printf("切片长度：%d
", len(slice)) // 切片长度：3
fmt.Printf("切片容量：%d
", cap(slice)) // 切片容量：5

slice = append(slice, 4)
fmt.Printf("切片长度：%d
", len(slice)) // 切片长度：4
fmt.Printf("切片容量：%d
", cap(slice)) // 切片容量：5

Dans le code ci-dessus, la longueur de la tranche est de 3 et la capacité est de 5. Lorsque l'opération d'ajout est effectuée, la capacité étant suffisante, la tranche ne réaffectera pas le tableau sous-jacent, la longueur passe à 4 et la capacité reste à 5.

6. Résumé

Grâce aux exemples de code et à l'analyse ci-dessus, nous avons une compréhension approfondie du fonctionnement du découpage du langage Go. En tant que structure de données flexible et efficace, le découpage joue un rôle important dans le développement du langage Go. Les développeurs doivent être familiers avec les caractéristiques et les principes de fonctionnement du découpage afin de mieux utiliser le découpage pour améliorer l'efficacité du code.

J'espère que cet article pourra aider les lecteurs à mieux comprendre le découpage du langage Go. Les lecteurs sont également invités à approfondir davantage leur compréhension et leur application du découpage par la pratique et l'exploration.

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!