Parlons de la façon d'utiliser les fonctions slicing et append() de Golang

Dans la tranche de Golang, append() est une fonction très importante et une fonction très fréquemment utilisée. Cet article explique comment utiliser les fonctions de découpage et d'append() de Golang.

1. Golang Slicing

Par rapport aux tableaux, le découpage a des fonctions plus puissantes dans Golang. Une tranche diffère d'un tableau dans le sens où sa longueur peut changer de manière dynamique. Dans Golang, une tranche est un type de référence qui pointe vers un tableau sous-jacent. Lorsque la capacité de la tranche est insuffisante, la taille de la tranche sera automatiquement augmentée si nécessaire.

La façon de définir une tranche est la suivante :

var s1 []int // []int 表示定义了一个 int 类型的切片

La longueur et la capacité de s1 à ce moment sont toutes deux 0, car le tableau sous-jacent n'est pas défini.

Une tranche d'une longueur de 5 et d'une capacité de 10 peut être implémentée à l'aide de la fonction make() :

s2 := make([]int, 5, 10) // 长度为 5，容量为 10

slice[index] peut accéder aux éléments de la tranche, qui sont essentiellement des éléments du tableau sous-jacent. slice[start:end] peut obtenir des sous-tranches du début (inclus) à la fin (exclusif). Par exemple :

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

2. Fonction append() La fonction

append() peut ajouter des éléments à la fin de la tranche et renvoyer une nouvelle tranche. La fonction append() a les utilisations suivantes.

1. Ajoutez des éléments à la fin de la tranche

Le code suivant ajoute des éléments à s1 et génère une nouvelle tranche :

s1 := []int{1, 2, 3, 4, 5}
s2 := append(s1, 6, 7)
fmt.Println(s1) // [1 2 3 4 5]
fmt.Println(s2) // [1 2 3 4 5 6 7]

Remarque : lorsque vous utilisez la fonction append() pour ajouter des éléments à la tranche, si la capacité est non dépassée, le tableau sous-jacent ne changera pas. Si la capacité est dépassée, un nouveau tableau sous-jacent sera généré.

2. Ajouter une tranche à une autre tranche

Le code suivant ajoute des éléments de s2 à s1, générant une nouvelle tranche :

s1 := []int{1, 2, 3, 4, 5}
s2 := []int{6, 7}
s3 := append(s1, s2...)
fmt.Println(s1) // [1 2 3 4 5]
fmt.Println(s2) // [6 7]
fmt.Println(s3) // [1 2 3 4 5 6 7]

Remarque : utilisez la fonction append() pour ajouter une tranche à une autre Lors du découpage, vous devez ajoutez trois points (...) après s2 pour indiquer que s2 est divisé et que les éléments sont supprimés.

3. Générez une nouvelle tranche via append()

Le code suivant crée une tranche s1 d'une longueur de 0 et d'une capacité de 0, puis y ajoute des éléments :

var s1 []int
s1 = append(s1, 1)
s1 = append(s1, 2, 3)
fmt.Println(s1) // [1 2 3]

La fonction append() renverra le slice nouvellement générée, si la longueur de la tranche d'origine n'est pas suffisante, un nouveau tableau sera créé, donc la fonction append() peut être utilisée lorsque la longueur de la tranche est 0.

3. Résumé

Grâce à l'introduction de cet article, nous avons découvert l'utilisation des fonctions de découpage Golang et append(). Le découpage est très important dans Golang et est très fréquemment utilisé dans le développement réel. Il est très important pour les développeurs Golang de maîtriser l'utilisation de base du découpage. Lorsque vous utilisez la fonction append(), vous devez faire attention à sa valeur de retour, et vous devez accorder une attention particulière à l'utilisation de l'opérateur ... pour diviser une tranche et l'ajouter à une autre tranche.

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!