Comment trier une tranche de structures avec des tranches imbriquées dans Go en fonction de plusieurs critères ?

Tri d'une tranche de structures avec des tranches imbriquées

Dans Go, vous pouvez trier des tranches de structures personnalisées à l'aide du package de tri intégré. Considérez le code suivant qui définit deux structures, Parent et Enfant, représentant une relation parent-enfant :

<code class="go">type Parent struct {
    id       string
    children []Child
}

type Child struct {
    id string
}</code>

Supposons que vous disposez d'une tranche de structures Parent et que vous souhaitez les trier en fonction de deux critères :

Critères de tri :

1. Triez la tranche Parent par Parent.id par ordre croissant.
2. Pour chaque Parent, triez la tranche enfants par Enfant. identifiant par ordre croissant au sein du parent.

Solution :

L'extrait de code fourni répond à l'exigence de tri :

``
// trier chaque parent dans la tranche des parents par Id
sort.Slice(parents, func(i, j int) bool {

return parents[i].id < parents[j].id })

// pour chaque parent, trier chaque enfant dans la children slice by Id
for _, parent := range parents {

sort.Slice(parent.children, func(i, j int) bool { 
    return parent.children[i].id < parent.children[j].id })

}
``

La fonction sort.Slice opère directement sur les tranches, éliminant ainsi le besoin pour les conteneurs intermédiaires.

1. Il trie la tranche des parents en fonction de Parent.id.
2. Pour chaque parent dans la tranche des parents triés, il trie la tranche des enfants en fonction de Child.id en utilisant une boucle imbriquée.

Le résultat s'aligne sur le résultat attendu :

[{1 [{7} {8} {9}]} {2 [{4} {5} {6}]} {3 [{1} {2} {3}]}]

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!