Comment utiliser les tranches en golang

golang est un langage de programmation très efficace et facile à apprendre. Il a été largement utilisé dans le développement de projets réels. Les tranches sont une structure de données très importante dans Golang, qui nous permet d'utiliser les tableaux et les tranches plus facilement. Cet article explique comment utiliser les tranches dans Golang.

1. Définir et initialiser des tranches

Dans Golang, les tranches peuvent être utilisées pour ajuster dynamiquement la taille des tableaux. Une tranche est représentée par un pointeur vers le tableau sous-jacent, une longueur et une capacité. La longueur d'une tranche fait référence au nombre d'éléments qu'elle contient et la capacité fait référence au nombre d'éléments qu'elle peut contenir. Par conséquent, nous pouvons définir et initialiser une tranche de la manière suivante :

var slice []int             // 通过 var 关键词声明一个空切片
slice1 := make([]int, 5)    // 通过 make 函数创建一个长度为 5 的切片
slice2 := []int{1, 2, 3}    // 直接指定切片中的元素
slice3 := []int{0: 1, 2: 3} // 通过索引初始化切片中的元素

2. Ajouter des éléments à la tranche

Utilisez la fonction append() pour ajouter des éléments à la tranche, ce qui agrandira automatiquement la tranche (si nécessaire). Un exemple est le suivant :

slice = append(slice, 1) // 在 slice 的末尾添加一个元素
slice = append(slice, 2, 3) // 在 slice 的末尾添加两个元素

Il est à noter que si la longueur de la tranche dépasse la capacité lors de l'ajout d'éléments, la fonction append() augmentera automatiquement la capacité. Lors du développement, golang créera un nouveau tableau sous-jacent et copiera les éléments d'origine dans le nouveau tableau. Par conséquent, il n'est pas recommandé d'ajouter un grand nombre d'éléments à une tranche dans plusieurs boucles, car cela entraînerait des opérations d'expansion fréquentes et affecterait les performances.

3. Supprimer des éléments de la tranche

En Golang, la suppression d'éléments dans la tranche est généralement réalisée en réaffectant des valeurs. Voici une implémentation courante :

slice = append(slice[:i], slice[i+1:]...) // 从切片中删除第 i 个元素

Ce code divisera la tranche d'origine en deux parties, puis les fusionnera. Parmi eux, slice[:i] signifie du début de la tranche jusqu'au i-ème élément (à l'exclusion du i-ème élément), et slice[i+1:] signifie du i+1-ème élément jusqu'à la fin. de la tranche. Parmi les deux tranches, l’une contient tous les éléments qui doivent être conservés et l’autre ne contient pas d’éléments qui doivent être supprimés. Enfin, combinez-les ensemble à l'aide de l'opérateur ....

De plus, nous pouvons également utiliser la fonction copy() pour supprimer des éléments. Un exemple est le suivant :

copy(slice[i:], slice[i+1:]) // 从切片中删除第 i 个元素
slice = slice[:len(slice)-1] // 删除切片中的最后一个元素

Dans le code ci-dessus, la fonction copy() déplacera tous les éléments après l'élément qui doit être supprimé d'une position vers l'avant, et enfin réduira la longueur de la tranche d'une pour atteindre l'objectif. de supprimer l'élément.

4. Copie et interception de tranches

Golang fournit deux fonctions intégrées pour copier et intercepter des tranches : copy() et append(). Ci-dessous, nous présentons respectivement l'utilisation de ces deux fonctions :

1. fonction copy()

var slice1 []int // 定义一个空切片
slice2 := make([]int, 5) // 创建一个长度为 5 的切片
copy(slice1, slice2) // 将 slice2 复制到 slice1 中

Il est à noter que la fonction copy() ne copiera que les mêmes éléments dans les deux tranches. Si la longueur de la tranche source est supérieure à la longueur de la tranche cible, seuls les éléments pouvant être logés dans la tranche cible seront copiés et les éléments en excès seront tronqués. Si la longueur de la tranche de destination est supérieure à la longueur de la tranche source, les éléments excédentaires dans la tranche de destination sont définis sur leurs valeurs par défaut.

2. Fonction append()

var slice1 []int // 定义一个空切片
slice2 := []int{1, 2, 3} // 创建一个切片并初始化
slice1 = append(slice1, slice2...) // 将 slice2 追加到 slice1 中

Il convient de noter que lorsque vous utilisez la fonction append(), si vous ajoutez une tranche à une autre tranche, vous devez utiliser l'opérateur ... pour la développer. De cette manière, la tranche source sera développée dans la tranche cible, plutôt que d’être ajoutée à la tranche cible dans son ensemble.

5. Traversée de tranche

Vous pouvez utiliser la boucle for dans Golang pour parcourir les éléments de la tranche. Un exemple est le suivant :

for i, val := range slice {
    fmt.Printf("Index: %d, Value: %d\n", i, val)
}

Dans le code ci-dessus, une forme de plage de boucle for est utilisée pour parcourir les éléments de la tranche. Parmi eux, i représente l'index de l'élément et val représente la valeur de l'élément. Comme vous pouvez le voir, l'utilisation de range nous permet de parcourir les éléments de la tranche plus facilement, ce qui est également la méthode de parcours recommandée dans Golang.

Résumé :

Cet article présente la définition et l'initialisation des tranches dans Golang, l'ajout d'éléments aux tranches, la suppression d'éléments des tranches, la copie et l'interception de tranches et le parcours de tranches. Les tranches sont une structure de données courante qui peut grandement simplifier les opérations sur les tableaux. Il est donc très important pour les développeurs Golang de maîtriser l’utilisation des slices.

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!