github.com/pmylund/sortutil

Sortutil is a Go library which lets you sort a slice without implementing a sort.Interface, and in different orderings: ascending, descending, or case-insensitive ascending or descending (for slices of strings.)

Additionally, Sortutil lets you sort a slice of a custom struct by a given struct field or index--for example, you can sort a []MyStruct by the structs' "Name" fields, or a [][]int by the second index of each nested slice, similar to using sorted(key=operator.itemgetter/attrgetter) in Python.

== Installation go get github.com/pmylund/sortutil

== Documentation go doc github.com/pmylund/sortutil or http://go.pkgdoc.org/github.com/pmylund/sortutil

== Functions func Asc(slice interface{}) Sort a slice in ascending order.

func AscByField(slice interface{}, name string) Sort a slice in ascending order by a field name.

func AscByFieldIndex(slice interface{}, index []int) Sort a slice in ascending order by a list of nested field indices, e.g. {1, 2, 3} to sort by the third field of the struct in the second field of the struct in the first field of each struct in the slice.

func AscByIndex(slice interface{}, index int) Sort a slice in ascending order by an index in a child slice.

func CiAsc(slice interface{}) Sort a slice in case-insensitive ascending order.

func CiAscByField(slice interface{}, name string) Sort a slice in case-insensitive ascending order by a field name. (Valid for string types.)

func CiAscByFieldIndex(slice interface{}, index []int) Sort a slice in case-insensitive ascending order by a list of nested field indices, e.g. {1, 2, 3} to sort by the third field of the struct in the second field of the struct in the first field of each struct in the slice. (Valid for string types.)

func CiAscByIndex(slice interface{}, index int) Sort a slice in case-insensitive ascending order by an index in a child slice. (Valid for string types.)

func CiDesc(slice interface{}) Sort a slice in case-insensitive descending order.

func CiDescByField(slice interface{}, name string) Sort a slice in case-insensitive descending order by a field name. (Valid for string types.)

func CiDescByFieldIndex(slice interface{}, index []int) Sort a slice in case-insensitive descending order by a list of nested field indices, e.g. {1, 2, 3} to sort by the third field of the struct in the second field of the struct in the first field of each struct in the slice. (Valid for string types.)

func CiDescByIndex(slice interface{}, index int) Sort a slice in case-insensitive descending order by an index in a child slice. (Valid for string types.)

func Desc(slice interface{}) Sort a slice in descending order.

func DescByField(slice interface{}, name string) Sort a slice in descending order by a field name.

func DescByFieldIndex(slice interface{}, index []int) Sort a slice in descending order by a list of nested field indices, e.g. {1, 2, 3} to sort by the third field of the struct in the second field of the struct in the first field of each struct in the slice.

func DescByIndex(slice interface{}, index int) Sort a slice in descending order by an index in a child slice.

func Reverse(slice interface{}) Reverse a slice.

=== Utility functions for types that already implement sort.Interface

func ReverseInterface(s sort.Interface) Reverse a type which implements sort.Interface.

func SortReverseInterface(s sort.Interface) Sort a type using its existing sort.Interface, then reverse it. For a slice with a "normal" sort interface (where Less returns true if i is less than j), this causes the slice to be sorted in descending order.

== Examples

=== Normal sorting

ints := []int{4, 7, 2, 6}

// Sort the int slice in descending order, such that // ints[0] == 7 // ints[1] == 6 // ints[2] == 4 // ints[3] == 2 sortutil.Desc(ints)

strings := []string{"ABC", "def", "abc", "GHI"}

// Sort the string slice in case-insensitive ascending order, such that: // strings[0] == "ABC" // strings[1] == "abc" // strings[2] == "def" // strings[3] == "GHI" sortutil.CiAsc(strings)

=== Nested sorting

type MyStruct struct { Id int Name string Date time.Time } now := time.Now() day := 24time.Hour structs := []MyStruct{ {3, "foo", now.Add(1day)}, {1, "bar", now.Add(-1*day)}, {2, "baz", now}, }

// Sort the slice by the Id field in ascending order, such that // structs[0].Id == 1 // structs[1].Id == 2 // structs[2].Id == 3 sortutil.AscByField(structs, "Id")

// Sort the slice by the Date field in ascending order, such that // structs[0].Date == yesterday // structs[1].Date == now // structs[2].Date == tomorrow sortutil.AscByField(structs, "Date")

// Sort the slice by the Name field in descending order, such that // structs[0].Name == "foo" // structs[1].Name == "baz" // structs[2].Name == "bar" sortutil.DescByField(structs, "Name")

ints := [][]ints{ {4, 5, 1}, {2, 1, 7}, {9, 3, 3}, {1, 6, 2}, }

// Sort the ints by the last number in child slices in ascending // order, such that // ints[0] == {4, 5, 1} // ints[1] == {1, 6, 2} // ints[2] == {9, 3, 3} // ints[3] == {2, 1, 7} sortutil.AscByIndex(ints, 2)

== Performance While sortutil is convenient, it won't beat a dedicated sort.Interface in terms of performance. Implementing sort.Interface for a type ByName which embeds e.g. []MyStruct and doing sort.Sort(ByName{MySlice}) should be considered when high performance is required.

See the top of sortutil/all_test.go, go/src/pkg/sort/example_interface_test.go, and go/src/pkg/sort/example_reverse_test.go for examples.