Comment supprimer les données en double dans Golang

Lors du traitement des données ou de la logique métier, il est souvent nécessaire de dédupliquer les données pour garantir l'exactitude et l'exhaustivité des données. Il existe de nombreuses façons de supprimer les données en double dans Golang. Voici quelques méthodes courantes.

Utiliser map

L'utilisation de map est l'un des moyens les plus courants de supprimer les données en double dans Golang. La carte est une structure de données de paire clé-valeur non ordonnée qui peut vérifier rapidement si une valeur existe dans la carte. Vous pouvez définir une carte pour stocker les données qui doivent être dédupliquées, puis parcourir la tranche et utiliser chaque élément de la tranche comme clé dans la carte, afin de pouvoir dédupliquer :

func RemoveDuplicate(slc []string) []string {
    m := make(map[string]bool)
    for _, v := range slc {
        if _, ok := m[v]; !ok {
            m[v] = true
        }
    }
    var result []string
    for k := range m {
        result = append(result, k)
    }
    return result
}

Dans le code ci-dessus, une carte m est d'abord défini, utilisé pour stocker les données dédupliquées. Parcourez ensuite la tranche, dans chaque boucle, prenez l'élément actuel comme clé dans la carte, si la clé n'existe pas dans la carte, ajoutez-la à la carte et définissez sa valeur sur true. Enfin, parcourt toutes les clés de la carte, les ajoute à la tranche de résultat et renvoie enfin la tranche de résultat.

Lorsque vous utilisez la carte pour supprimer les doublons, vous devez faire attention aux points suivants :

• Les données ne sauvegardent pas la commande. Si vous devez sauvegarder la commande, vous pouvez utiliser d'autres méthodes.
• Si vous devez enregistrer des données supplémentaires dans la carte, vous devez utiliser la valeur de la carte comme structure et enregistrer les données supplémentaires dans la structure.
• Si vous devez enregistrer des types de données complexes, tels que des structures, etc. dans la carte, vous devez implémenter la méthode Equal de ce type et utiliser cette méthode dans la carte à des fins de comparaison.

Utilisation de tranches

Les tranches sont également l'une des structures de données couramment utilisées dans Golang. Les tranches peuvent ajouter de nouveaux éléments via la méthode append et peuvent être triées à l'aide d'un algorithme de tri, afin de pouvoir être utilisées pour les opérations de déduplication.

func RemoveDuplicate(slc []string) []string {
    var result []string
    for i := range slc {
        found := false
        for j := range result {
            if slc[i] == result[j] {
                found = true
                break
            }
        }
        if !found {
            result = append(result, slc[i])
        }
    }
    return result
}

Dans le code ci-dessus, un résultat de tranche vide est d'abord défini pour stocker les données dédupliquées. Parcourez ensuite la tranche d'origine, et pour chaque élément, parcourez la tranche de résultat et vérifiez si l'élément existe dans le résultat. S'il n'existe pas, l'élément est ajouté au résultat. S'il existe, continuez à parcourir l'élément suivant.

Utilisation des collections

Dans Golang, vous pouvez également utiliser des types de collections pour supprimer les données en double. Un ensemble est une structure de données non ordonnée et non répétitive qui peut être comparée et recherchée à l'aide d'éléments de l'ensemble, afin de pouvoir être utilisée pour des opérations de déduplication. Il n'existe pas de type de collection direct dans Golang, mais il peut être implémenté à l'aide de bibliothèques tierces telles que le package setdata ou à l'aide des map/maps de Go.

func RemoveDuplicate(slc []string) []string {
    set := make(map[string]struct{})
    result := make([]string, 0)
    for _, v := range slc {
        if _, ok := set[v]; !ok {
            set[v] = struct{}{}
            result = append(result, v)
        }
    }
    return result
}

Dans le code ci-dessus, un ensemble de cartes vide et un résultat de tranche vide sont d'abord définis pour stocker les données dédupliquées. Parcourez ensuite la tranche d'origine et, pour chaque élément, vérifiez si l'élément existe dans l'ensemble, sinon, ajoutez-le à l'ensemble et ajoutez l'élément à la tranche résultante. S'il existe, continuez à parcourir l'élément suivant.

Ci-dessus sont plusieurs méthodes courantes pour supprimer les données en double dans Golang. Choisissez la méthode appropriée à mettre en œuvre en fonction des besoins réels.

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!