Comment trier struct avec de multiples paramètres de tri?

Utiliser la plus récente sort.Slice de la fonction en tant que telle:

sort.Slice(members, func(i, j int) bool {
    switch strings.Compare(members[i].FirstName, members[j].FirstName) {
    case -1:
        return true
    case 1:
        return false
    }
    return members[i].LastName > members[j].LastName
})

ou quelque chose comme ça.

Le plus court et toujours compréhensible code, j'ai réussi à écrire pour ce qui est:

package main

import (
    "fmt"
    "sort"
)

type Member struct {
    Id        int
    LastName  string
    FirstName string
}

func sortByLastNameAndFirstName(members []Member) {
    sort.SliceStable(members, func(i, j int) bool {
        mi, mj := members[i], members[j]
        switch {
        case mi.LastName != mj.LastName:
            return mi.LastName < mj.LastName
        default:
            return mi.FirstName < mj.FirstName
        }
    })
}

Le modèle à l'aide de la switch déclaration s'étend facilement à plus de deux critères de tri et est encore assez court pour être lu.

Voici le reste du programme:

func main() {
    members := []Member{
        {0, "The", "quick"},
        {1, "brown", "fox"},
        {2, "jumps", "over"},
        {3, "brown", "grass"},
        {4, "brown", "grass"},
        {5, "brown", "grass"},
        {6, "brown", "grass"},
        {7, "brown", "grass"},
        {8, "brown", "grass"},
        {9, "brown", "grass"},
        {10, "brown", "grass"},
        {11, "brown", "grass"},
    }

    sortByLastNameAndFirstNameFunctional(members)

    for _, member := range members {
        fmt.Println(member)
    }
}

Une toute autre idée, mais même API

Si vous voulez éviter de mentionner les champs LastName et FirstName plusieurs fois et si vous voulez éviter de mélanger i et j (ce qui peut arriver tous les sens), j'ai joué un peu et l'idée de base est:

func sortByLastNameAndFirstNameFunctional(members []Member) {
    NewSorter().
        AddStr(member -> member.LastName).
        AddStr(member -> member.FirstName).
        AddInt(member -> member.Id).
        SortStable(members)
}

Depuis Go ne prend pas en charge la -> opérateur pour la création de fonctions anonymes et n'ont pas de génériques, comme Java, un peu de syntaxe supplémentaire n'est nécessaire:

func sortByLastNameAndFirstNameFunctional(members []Member) {
    NewSorter().
        AddStr(func(i interface{}) string { return i.(Member).LastName }).
        AddStr(func(i interface{}) string { return i.(Member).FirstName }).
        AddInt(func(i interface{}) int { return i.(Member).Id}).
        SortStable(members)
}

La mise en œuvre ainsi que l'API est un peu moche à l'aide de interface{} et de réflexion, mais il ne mentionne que chaque champ une fois, et le code de l'application n'a pas une seule chance de accidentellement mélanger les indices i et j car il n'a pas affaire avec eux.

J'ai conçu cette API dans l'esprit de Java Comparateur.la comparaison.

L'infrastructure de code ci-dessus par le trieur:

type Sorter struct{ keys []Key }
func NewSorter() *Sorter { return new(Sorter) }
func (l *Sorter) AddStr(key StringKey) *Sorter { l.keys = append(l.keys, key); return l }
func (l *Sorter) AddInt(key IntKey) *Sorter    { l.keys = append(l.keys, key); return l }
func (l *Sorter) SortStable(slice interface{}) {
value := reflect.ValueOf(slice)
sort.SliceStable(slice, func(i, j int) bool {
si := value.Index(i).Interface()
sj := value.Index(j).Interface()
for _, key := range l.keys {
if key.Less(si, sj) {
return true
}
if key.Less(sj, si) {
return false
}
}
return false
})
}
type Key interface {
Less(a, b interface{}) bool
}
type StringKey func(interface{}) string
func (k StringKey) Less(a, b interface{}) bool  { return k(a) < k(b) }
type IntKey func(interface{}) int
func (k IntKey) Less(a, b interface{}) bool  { return k(a) < k(b) }

Ici est un peu plus concis mise en œuvre de la accepté de répondre:

package main
import (
"fmt"
"sort"
)
type Member struct {
FirstName string
LastName  string
}
func main() {
members := []Member{
{"John", "Doe"},
{"Jane", "Doe"},
{"Mary", "Contrary"},
}
fmt.Println(members)
sort.Slice(members, func(i, j int) bool {
return members[i].LastName < members[j].LastName || members[i].FirstName < members[j].FirstName
})
fmt.Println(members)
}

En cours d'exécution imprimer les résultats suivants:

[{John Doe} {Jane Doe} {Mary Contrary}]
[{Mary Contrary} {Jane Doe} {John Doe}]

C'est comme prévu: les membres sont imprimés dans l'ordre croissant de nom de famille, où, dans le cas d'une cravate, ils sont imprimées dans l'ordre des prénoms.