Comment puis-je regrouper et additionner efficacement une tranche de structures en fonction de champs spécifiques dans Golang ?

Regroupement et sommation efficaces des tranches de structure dans Golang

Dans Golang, la gestion efficace des données est cruciale. Lorsqu'il s'agit de tranches de structures, des tâches telles que le regroupement et la sommation peuvent devenir difficiles. Ce guide présente une approche efficace pour regrouper et additionner une tranche de structures en fonction de champs spécifiques.

Énoncé du problème

Considérez la structure suivante :

type Register struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
    money int
}

Le but est de regrouper les registres par champs id1, id2, id3, id4, id5, id6, id7 et id8 puis d'additionner le champ money associé.

Solution

La solution fournie implique une légère refactorisation des types de structure. En extrayant les champs clés dans une structure distincte, Key, nous pouvons utiliser la comparabilité des structures dans Golang.

Types refactorisés

type Key struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
}

type Register struct {
    key   Key
    money int
}

Regroupement et Sommation

Pour réaliser le regroupement et la sommation, nous créons un map[Key]int. La Clé de la carte représente la combinaison des champs d'identification, tandis que la valeur représente la somme d'argent pour les registres avec la même clé.

regs := []*Register{
    {Key{id1: 345}, 1500},
    {Key{id1: 345, id2: 140}, 2700},
    {Key{id1: 345, id2: 140}, 1300},
    {Key{id1: 345}, 1000},
    {Key{id3: 999}, 1000},
    {Key{id3: 999}, 2000},
}

// calculate sum:
m := map[Key]int{}
for _, v := range regs {
    m[v.key] += v.money
}

Sortie

La map fournit une représentation groupée et additionnée des registres.

map[{345 0 0 0 0 0 0 0}:2500 {345 140 0 0 0 0 0 0}:4000 {0 0 999 0 0 0 0 0}:3000]

Sortie améliorée

Pour une meilleure lisibilité, nous pouvons formater la sortie comme suit :

fmt.Println("Nice output:")
for k, v := range m {
    fmt.Printf("%+3v: %d\n", k, v)
}

Résultat

Nice output:
{id1:345 id2:  0 id3:  0 id4:  0 id5:  0 id6:  0 id7:  0 id8:  0}: 2500
{id1:345 id2:140 id3:  0 id4:  0 id5:  0 id6:  0 id7:  0 id8:  0}: 4000
{id1:  0 id2:  0 id3:999 id4:  0 id5:  0 id6:  0 id7:  0 id8:  0}: 3000

Avantages

Cette approche offre plusieurs avantages :

• Simplifiée regroupement et addition à l'aide de cartes
• Gestion efficace des données en tirant parti de structures comparables
• Flexibilité dans la gestion de différents critères de regroupement grâce à l'utilisation de la structure clé

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!