Comment supprimer des éléments à l'aide de la plage de Golang

Le langage Go est un langage de programmation open source qui prend en charge une programmation à haute concurrence et hautes performances. De nombreuses entreprises ont commencé à utiliser et à prendre en charge ce langage. Parmi eux, Golang a attiré beaucoup d'attention en raison de sa syntaxe concise, de sa lisibilité élevée du code et de sa vitesse d'exécution rapide.

Dans Golang, range est un mot-clé très important, qui peut être utilisé pour traiter des données de type collection telles que des tableaux, des tranches, des chaînes et des cartes. Nous utilisons généralement le mot-clé range pour parcourir ces types de collections de données. Cependant, lorsque nous devons modifier les éléments de la collection tout en utilisant range, nous rencontrons un problème : l'utilisation de range pendant l'itération de la boucle entraînera l'invalidité de l'itérateur, provoquant ainsi une série de problèmes. Cet article présentera en détail comment utiliser la plage de Golang pour supprimer des éléments.

Tout d'abord, regardez un exemple simple :

package main

import (
    "fmt"
)

func main() {
    nums := []int{1, 2, 3, 4, 5}
    for idx, val := range nums {
        if (idx == 2) {
            nums = append(nums[:idx], nums[idx+1:]...)
        }
        fmt.Println("val:", val)
    }
    fmt.Println("nums:", nums)
}

Le résultat après l'exécution est le suivant :

val: 1
val: 2
val: 4
val: 5
nums: [1 2 4 5]

Nous constaterons que pendant le processus de parcours du tableau, en utilisant le mot-clé range et en modifiant la taille de la tranche, certains éléments le font réellement non Non traversé. En effet, pendant le processus de parcours, l'expression nums[:idx] est utilisée, ce qui modifie en fait la longueur des nums, et l'itérateur ne parvient pas à obtenir la longueur actuelle de la tranche, ce qui pose certains problèmes.

Pour contourner ce problème, nous pouvons utiliser deux variables de boucle pour parcourir les tranches. La première variable est utilisée pour parcourir les éléments de tranche et la deuxième variable est utilisée pour enregistrer la position d'itération actuelle. Ensuite, nous pouvons traiter tous les éléments à l'intérieur de la boucle, et enfin supprimer tous les éléments qui doivent être supprimés en même temps. Comme dans l'exemple suivant :

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}
    var newNums []int
    var keepIdx []int
    for idx, val := range nums {
        if val%2 == 0 {
            keepIdx = append(keepIdx, idx)
        }
        newNums = append(newNums, val)
    }
    for i := len(keepIdx) - 1; i >= 0; i-- {
        newNums = append(newNums[:keepIdx[i]], newNums[keepIdx[i]+1:]...)
    }
    fmt.Println(newNums) // [1 3 5]
}

Dans cet exemple, on crée deux nouvelles variables newNums et keepIdx pour sauvegarder la nouvelle tranche et l'index de l'élément à conserver. Dans la première boucle, nous ajoutons tous les éléments à la nouvelle tranche et ajoutons l'index de l'élément qui doit être conservé au tableau keepIdx. Dans la deuxième boucle, nous ajoutons tous les éléments à la tranche newNums à l'exception des éléments qui doivent être supprimés.

Enfin, lorsque nous utilisons range pour supprimer des éléments de collection, nous devons faire particulièrement attention à ne pas permettre à la taille de la collection de changer pendant le processus d'itération. Nous pouvons d'abord parcourir tous les éléments, enregistrer les indices des éléments qui doivent être supprimés, puis supprimer ces éléments en même temps. Cela évite les problèmes de non-concordance d'index et d'éléments causés par le processus itératif.

En résumé, la méthode d'utilisation de la plage de Golang pour supprimer des éléments n'est rien de plus que deux points : l'un consiste à éviter de modifier la taille de la collection pendant le processus d'itération, et l'autre est d'être particulièrement prudent lors de la modification des éléments, ce qui peut provoquer le l'itérateur échoue. Si nous pouvons utiliser ces deux points habilement, alors utiliser range pour supprimer des éléments deviendra facile.

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!