méthode de tranche de golang Op

【Avant-propos】

Le langage Slice in Go est une structure de données très courante et est souvent utilisé pour les opérations sur les tableaux dynamiques. Lors de son utilisation, nous devons souvent effectuer des opérations telles que l'ajout, la suppression, la vérification et la modification de tranches, et le langage Go fournit des méthodes intégrées pour implémenter ces opérations. Cet article présentera en détail l'utilisation de base et les méthodes courantes de découpage dans le langage Go.

【1. Définition de slice】

Une slice est une séquence de longueur variable, définie comme :

var arr []type

Le type ici peut être n'importe quel type, tel que int, string, etc. Vous pouvez également utiliser la méthode make() pour créer directement une tranche :

arr := make([]type, len, cap)

où, len représente la longueur de la tranche, et cap représente la capacité de la tranche. Ce qu’il faut noter ici, c’est que la capacité de la tranche est supérieure ou égale à la longueur.

【2. Opérations de base du découpage】

2.1 Traversée des tranches

Vous pouvez utiliser le mot-clé range pour parcourir les tranches. L'exemple de code est le suivant :

arr := []string{"hello", "world", "go"}

for index, value := range arr {
    fmt.Printf("index:%d, value:%s
", index, value)
}

Le résultat de sortie est :

index:0, value:hello
index:1, value:world
index:2, value:go

2.2 Ajout de tranches

.

Ajouter à la tranche Les éléments peuvent utiliser la méthode append(), comme indiqué ci-dessous :

var arr []string
arr = append(arr, "hello")

Il convient de noter ici qu'après avoir utilisé la méthode append(), sa valeur de retour doit être réaffectée à la tranche.

2.3 Suppression de tranches

Pour supprimer des éléments dans une tranche, vous pouvez utiliser la méthode delete() intégrée, comme indiqué ci-dessous :

arr := []string{"hello", "world", "go"}

arr = append(arr[:1], arr[2:]...)

La syntaxe ici est très délicate, nous pouvons la diviser en trois parties :

• arr [:1] : représente les éléments de 0 à 1 (hors 1), soit "bonjour"
• arr[2:] : représente les éléments de 2 au dernier élément du tableau (hors 2) ; ), c'est-à-dire "go";
• ...signifie fusionner deux tranches.

Le résultat final est de supprimer l'élément "world" d'index 1.

2.4 Modification des tranches

Pour modifier les éléments de la tranche, vous pouvez attribuer des valeurs directement via des indices, comme indiqué ci-dessous :

arr := []string{"hello", "world", "go"}

arr[1] = "Golang"

fmt.Println(arr)

Le résultat de sortie est :

[hello Golang go]

[3.

Énumérez-en quelques-unes ici Méthodes de découpage couramment utilisées :

Méthode 3.1 len()

La méthode len() est utilisée pour obtenir la longueur de la tranche. L'exemple de code est le suivant :

arr := []string{"hello", "world", "go"}

fmt.Println(len(arr))

Le résultat de sortie est :

3

. 3.2 Méthode cap()

Méthode cap() Utilisée pour obtenir la capacité d'une tranche, l'exemple de code est le suivant :

arr := make([]string, 3, 5)

fmt.Println(cap(arr))

Le résultat de sortie est :

5

3.3 Méthode copy()

La méthode copy() peut copiez la valeur d'une tranche dans une autre tranche, l'exemple de code est le suivant :

var arr1 = []string{"apple", "banana", "orange"}

var arr2 = make([]string, 3)

copy(arr2, arr1)

fmt.Println(arr2)

Le résultat de sortie est :

[apple banana orange]

3.4 Méthode append()

La méthode append() est utilisée pour ajouter des éléments à la tranche Le code. L'exemple est le suivant :

arr := []string{"hello", "world", "go"}

arr = append(arr, "Golang")

fmt.Println(arr)

Le résultat de sortie est :

[hello world go Golang]

3.5 Méthode append() et expansion

Lorsque la capacité de la tranche n'est pas suffisante pour accueillir le nouvel élément, la méthode append() augmentera automatiquement la capacité . Les conditions d'expansion sont :

Si la longueur du nouvel élément est inférieure à 1024, la capacité de la tranche sera doublée
• Si la longueur du nouvel élément est supérieure ou égale à 1024 ; , chaque extension augmentera de 1/4 de la capacité d'origine jusqu'à ce que la capacité soit suffisante.

3.6 Paramètres variables de la méthode append()

Les paramètres d'entrée de la méthode append() peuvent être des paramètres variables, et plusieurs éléments peuvent être ajoutés à la tranche. L'exemple de code est le suivant :

arr := []string{"hello", "world", "go"}

arr = append(arr, "Golang", "Python")

fmt.Println(arr)

La sortie. le résultat est :

[hello world go Golang Python]

[Résumé]

Cet article fournit une introduction détaillée à l'utilisation de base et aux méthodes courantes de découpage dans le langage Go. J'espère qu'il sera utile à tout le monde. Dans le code réel, l’utilisation flexible du découpage peut rendre notre code plus concis et efficace.

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!