web-dev-qa-db-fra.com

trier une tranche d'uint64 au go

J'écris l'application Go en utilisant Go 1.7rc3.

J'ai une tranche de uint64 (var dirRange []uint64) que je veux trier.

le paquet de tri a une fonction sort.Ints() mais il nécessite []int et j'ai []uint64. 

que fais-je? puis-je taper jeté la totalité de la tranche?

merci

goslice
13
ufk

A partir de la version 1.8, vous pouvez utiliser la fonction plus simple sort.Slice . Dans votre cas, ce serait quelque chose comme ce qui suit:

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

Cela évite d'avoir à définir n'importe quel type uniquement pour le tri.

18
vicentazo

Vous pouvez définir sort.Interface sur votre dirRange, qui peut être un alias de type []uint64:

type DirRange []uint64

func (a DirRange) Len() int           { return len(a) }
func (a DirRange) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a DirRange) Less(i, j int) bool { return a[i] < a[j] }

func main() {
    dirRange := DirRange{2, 5, 7, 1, 9, 4}
    sort.Sort(dirRange)
    fmt.Println(dirRange)   
}

Sortie:

[1 2 4 5 7 9]

De cette façon, vous pouvez éviter le casting et travailler directement avec votre tableau. Comme le type sous-jacent est une tranche []uint64, vous pouvez toujours utiliser les opérations de tranche générales. Par exemple:

dirRange := make(DirRange, 10)
dirRange = append(dirRange, 2)
8
abhink

Vous pouvez fournir un alias de type pour [] uint64, ajouter les méthodes de tri standard "boilerplate" pour implémenter sort.interface (Len, Swap et Less - https://golang.org/pkg/sort/#Interface ); Vous pouvez ensuite créer une instance du nouveau type ou transtyper une tranche existante [] uint64 dans le nouveau type, comme dans l'exemple suivant (également https://play.golang.org/p/BbB3L9TmBI ):

package main

import (
    "fmt"
    "sort"
)

type uint64arr []uint64

func (a uint64arr) Len() int           { return len(a) }
func (a uint64arr) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a uint64arr) Less(i, j int) bool { return a[i] < a[j] }
func (a uint64arr) String() (s string) {
    sep := "" // for printing separating commas
    for _, el := range a {
        s += sep
        sep = ", "
        s += fmt.Sprintf("%d", el)
    }
    return
}

func main() {
    dirRange := []uint64{3, 2, 400000}
    arr := uint64arr(dirRange)
    sort.Sort(arr)
    fmt.Printf("%s\n", arr)
    fmt.Printf("%#v\n", dirRange)
}

La sortie est:

2, 3, 400000
[]uint64{0x2, 0x3, 0x61a80}

montrant que les deux tableaux sont triés puisque le second est un alias transtypé pour l'original. 

0
dmitris