在go中排序uint64切片

I'm writing Go application using Go 1.7rc3.

I have a slice of uint64 (var dirRange []uint64) that I want to sort.

the sort package has a function sort.Ints() but it requires []int and I have []uint64.

what do I do? can I type cast the all slice ?

thanks

As of version 1.8, you can use the simpler function sort.Slice. In your case, it would be something like the following:

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

This avoids having to define any type just for the sorting.

You can define sort.Interface on your dirRange, which can be a type aliasing []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)   
}

Output:

[1 2 4 5 7 9]

This way you can avoid casting and work directly with your array. Since the underlying type is a slice []uint64, you can still use general slice operations. For example:

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

You can provide a type alias for []uint64, add the standard "boilerplate" sorting methods to implement sort.interface (Len, Swap, and Less - https://golang.org/pkg/sort/#Interface); then either create an instance of the new type or typecast an existing slice []uint64 into the new type, as done in the following example (also 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
", arr)
    fmt.Printf("%#v
", dirRange)
}

The output is:

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

showing that both arrays are sorted since the second one is a typecasted alias for the original.