golang sorte de tranche croissant ou décroissant

J'ai besoin de trier une tranche d'un type qui est à venir à partir d'un 3rdparty paquet. Basée sur une condition de l'ordonnance doit être croissant ou décroissant.

La solution que j'ai est:

type fooAscending []foo

func (v fooAscending) Len() int           { return len(v) }
func (v fooAscending) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
func (v fooAscending) Less(i, j int) bool { return v[i].Amount < v[j].Amount }

type fooDescending []foo

func (v fooDescending) Len() int           { return len(v) }
func (v fooDescending) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
func (v fooDescending) Less(i, j int) bool { return v[i].Amount > v[j].Amount }

if someCondition {
    sort.Sort(fooAscending(array))
} else {
    sort.Sort(fooDescending(array))
}

Est-il une meilleure façon de le faire. 13 lignes de code pour cette tâche, et la plupart des il est dupliqué, semble un peu trop.

OriginalL'auteur gsf | 2016-06-08

  1. 25

    Que d'Aller 1.8, il y a un moyen plus facile de trier une tranche qui ne vous obligent pas à définir de nouveaux types. Il vous suffit de créer un Moins (anonyme) lambda.

    a := []int{5, 3, 4, 7, 8, 9}
sort.Slice(a, func(i, j int) bool {
    return a[i] < a[j]
})
for _, v := range a {
    fmt.Println(v)
}

    Cela permettra de trier dans l'ordre croissant, si vous voulez le contraire, il suffit d'écrire a[i] > a[j] dans le lambda.

    Quelqu'un ajouter un lien vers la doc: golang.org/pkg/sort/#Slice

    OriginalL'auteur Franck Jeannin

  2. 9

    Vous êtes à la recherche pour trier.Inverse. Qui vous permettra de dire:

    sort.Sort(sort.Reverse(fooAscending(s)))

    OriginalL'auteur cnicutar

  3. 4

    Ma réponse ci-dessous est basé sur l'hypothèse que la tranche que vous recevez à partir d'un tiers package de base d'un Aller de type.

    Pour trier les tranches de types de base, utiliser le tri package d'utilitaires. Voici un exemple qui trie une tranche de chaîne et une tranche de int.

    package main

import (
    "fmt"
    "sort"
)

func main() {
    sl := []string{"mumbai", "london", "tokyo", "seattle"}
    sort.Sort(sort.StringSlice(sl))
    fmt.Println(sl)

    intSlice := []int{3,5,6,4,2,293,-34}
    sort.Sort(sort.IntSlice(intSlice))
    fmt.Println(intSlice)
}

    La sortie de la ci-dessus est:

    [london mumbai seattle tokyo]
[-34 2 3 4 5 6 293]

    Aller à Aller au terrain de jeu ici de l'essayer vous-même.

    Quelques choses à noter:

    1. De tri de base Go types de ne pas nécessiter la mise en œuvre des fonctions telles que Len() qui appartiennent à trier.De l'Interface. Vous devez prendre cette route uniquement pour les types de composé.

    2. Juste envelopper le type d'un type de base en utilisant la méthode de l'Interface fournisseur, par exemple StringSlice, IntSlice, ou Float64Slice, et de les trier.

    3. La tranche est triée en place, et donc de ne pas renvoyer une copie de la triés tranche.

    OriginalL'auteur Tapan Karecha