Comment configurer des tranches de Golang

Golang est l'un des langages de programmation qui a attiré beaucoup d'attention ces dernières années. Il possède non seulement une efficacité élevée et d'excellentes capacités de traitement simultané, mais présente également de nombreux avantages tels qu'une syntaxe facile à apprendre et concise. En tant que l'un des composants importants de Golang, les tranches sont souvent utilisées dans le développement. Alors, comment configurer des tranches dans Golang ? Regardons de plus près ci-dessous.

Qu'est-ce que le tranchage ?

Dans Golang, une tranche est une structure de données similaire à un tableau, mais elle a une flexibilité et une variabilité plus élevées. Une tranche peut être considérée comme un tableau dynamique, la longueur n'est pas fixe et des éléments peuvent être ajoutés ou supprimés à volonté. La structure sous-jacente d'une tranche est similaire à un tableau, mais elle n'est pas de longueur fixe mais peut être étendue dynamiquement.

Définition et utilisation des tranches

Définir une tranche en Golang est très simple, il suffit d'utiliser "[]" pour la déclarer Le format de syntaxe est le suivant :

var a []int //Définir une tranche a de type. int

Vous pouvez également utiliser la fonction make intégrée pour créer une tranche avec une capacité initiale de 0, comme suit :

a := make([]int, 0) //Créez une tranche de type int avec une initiale capacité de 0

Vous pouvez voir Out, le premier paramètre de la fonction make est le type de la tranche correspondante, le deuxième paramètre est la longueur de la tranche et le troisième paramètre est la capacité de la tranche (facultatif). La longueur représente le nombre d'éléments actuellement dans la tranche et la capacité représente le nombre d'éléments que la tranche peut actuellement stocker.

Ensuite, nous pouvons ajouter des éléments à la tranche via la fonction append, comme suit :

a = append(a, 1) //Ajouter l'élément 1 à la tranche a

La méthode append ici est une fonction intégrée à Golang , peut être utilisé pour ajouter des éléments à une tranche. Après l'ajout, les éléments de la tranche passent de 0 à 1.

Assignation et copie de tranches

Dans Golang, l'affectation et la copie de tranches sont assez simples. Ce sont des pointeurs vers le tableau sous-jacent. Par conséquent, lors de l'affectation ou de la copie, vous copiez uniquement le pointeur de tranche sans copier le tableau sous-jacent. une copie.

Ce qui suit est un exemple :

a := []int{1,2,3} //Définir une tranche a
b := a //Attribuer a à b
b[0] = 4 //Modifier La valeur de la tranche b est [4 2 3]
fmt.Println(a) //La valeur de la sortie a est [4 2 3]

Vous pouvez voir qu'après avoir attribué a à b, la modification des éléments dans b affectera à la valeur de l'élément dans a. A l’inverse, modifier un élément dans a affectera également la valeur d’un élément dans b. En effet, a et b pointent vers le même tableau sous-jacent.

Bien sûr, si vous devez copier une tranche sans modifier le tableau d'origine, vous pouvez utiliser la fonction de copie pour faire une copie complète, comme suit :

a := []int{1,2,3}
b := make( []int, len(a))
copy(b, a) //Copier la valeur de la tranche a dans la tranche b
b[0] = 4
fmt.Println(a) //La valeur de la sortie a est [ 1 2 3]
fmt.Println(b) //La valeur de la sortie b est [4 2 3]

Vous pouvez voir qu'après avoir utilisé la fonction de copie pour copier la valeur de la tranche a dans la tranche b, modifier les éléments de b Cela n’affectera pas la valeur des éléments de a.

Extension de tranche

L'expansion de tranche signifie que lorsque la capacité de la tranche est insuffisante, elle doit être étendue dynamiquement pour accueillir plus d'éléments. Lorsque la capacité de la tranche est insuffisante, Golang réallouera un espace mémoire plus grand en bas et copiera les éléments de la tranche d'origine dans la nouvelle mémoire.

Lorsqu'une tranche est agrandie, Golang tentera de s'étendre selon les règles suivantes :

1. Si la nouvelle longueur est inférieure ou égale à 2 fois la longueur d'origine, la capacité de la nouvelle tranche sera 2 fois l'originale longueur.
2. Sinon, la nouvelle capacité de tranche est la longueur plus 1.

Voici un exemple :

a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
fmt.Println(len(a), cap(a)) //Sortie : 10 10

a = append(a, 10) //Ajouter un élément
fmt.Println(len(a), cap(a )) //Sortie : 11 20

Comme vous pouvez le voir, après avoir ajouté l'élément 10 à la tranche, la capacité est étendue à 20, soit 2 fois la longueur d'origine.

Résumé

Slice in Golang est une structure de données très pratique qui a des caractéristiques similaires aux tableaux, mais qui est plus flexible et modifiable. Lorsque nous utilisons des tranches, nous devons comprendre les connaissances de base de la définition, de l'affectation, de la copie et de l'expansion des tranches, et créer des applications raisonnables basées sur les besoins réels. Je pense que grâce à l'introduction de cet article, les lecteurs devraient avoir une compréhension plus approfondie des paramètres de découpage dans 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!