Comment puis-je regrouper et additionner des tranches de structures dans Go à l'aide de cartes et de structures clés ?

Regrouper et additionner des tranches de structures dans Go

Lors de l'analyse des données, il est souvent nécessaire de regrouper des éléments similaires et de calculer des valeurs agrégées pour chaque groupe. Dans LINQ, cela peut être réalisé efficacement à l'aide de requêtes en mémoire. Go fournit un moyen polyvalent d'effectuer des opérations similaires à l'aide de cartes et de fermetures.

Considérez une tranche de structures Register, où chaque structure contient plusieurs identifiants uniques (id1 à id8) et une valeur entière (argent). L'objectif est de regrouper ces registres par leurs identifiants uniques et d'additionner les valeurs monétaires correspondantes pour chaque groupe.

Regroupement et sommation manuels :

Une approche consiste à créer un Fonction Equal personnalisée pour comparer les structures Register en fonction de leurs identifiants. Ensuite, parcourez la tranche, en vérifiant si chaque registre est déjà présent dans une table de hachage. Si tel est le cas, la valeur monétaire est augmentée. Si ce n'est pas le cas, une nouvelle entrée est ajoutée à la table de hachage contenant le registre et une valeur monétaire initiale de 0.

À l'aide d'une structure de clé et d'une carte :

Les cartes de Go offrent un moyen plus efficace d'effectuer des opérations de regroupement et de sommation. En définissant une structure Key distincte qui contient uniquement les identifiants uniques (id1 à id8), vous pouvez l'utiliser comme clé unique pour une carte. Les valeurs dans la carte peuvent être la somme des valeurs monétaires pour les registres avec la même combinaison d'identifiants.

Pour mettre en œuvre cette approche :

• Définissez les structures Key et Register :

<code class="go">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
}</code>

• Remplissez une carte en utilisant la clé comme clé et la valeur monétaire initiale comme valeur :

<code class="go">m := map[Key]int{}</code>

• Parcourez les registres, en les ajoutant à la carte ou en mettant à jour leur valeur monétaire correspondante :

<code class="go">for _, v := range regs {
    m[v.key] += v.money
}</code>

Sortie et formatage :

Pour afficher joliment les résultats, vous pouvez formater le Structure clé avec tous ses champs préfixés par id. Par exemple :

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

Conclusion :

L'utilisation de cartes avec des structures clés est un moyen efficace et flexible de regrouper et d'additionner des tranches de structures dans Go. Il offre une alternative performante au regroupement et à la sommation manuels, en particulier lorsqu'il s'agit de grands ensembles de données.

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!