Sort

sort package defines an interface whose name is Interface: 

  1. type Interface interface {  
  2.         // Len is the number of elements in the collection.  
  3.         Len() int  
  4.         // Less reports whether the element with  
  5.         // index i should sort before the element with index j.  
  6.         Less(i, j int) bool  
  7.         // Swap swaps the elements with indexes i and j.  
  8.         Swap(i, j int)  
  9. }

For slice, or any other collection types, provided that it implements the Len(), Less and Swap functions, you can use sort.Sort() function to arrange the elements in the order.

Let’s see the following example: 

  1. package main
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. type command struct  {
  9.     name string
  10. }
  12. type byName []command
  14. func (a byName) Len() int           { return len(a) }
  15. func (a byName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
  16. func (a byName) Less(i, j int) bool { return a[i].name < a[j].name }
  19. func main() {
  20.     c := []command{
  21.         {"breakpoint"},
  22.         {"help"},
  23.         {"args"},
  24.         {"continue"},
  25.     }
  26.     fmt.Println("Before sorting: ", c)
  27.     sort.Sort(byName(c))
  28.     fmt.Println("After sorting: ", c)
  29. }

To avoid losing focus of demonstrating how to use sort.Interface, the command struct is simplified to only contain one string member: name. The comparison method (Less) is just contrasting the name in alphabetic order.

Check the running result of the program: 

  1. Before sorting:  [{breakpoint} {help} {args} {continue}]
  2. After sorting:  [{args} {breakpoint} {continue} {help}]

We can see after sorting, the items in c are rearranged.

Additionally, if you pick at the performance, you may define a slice whose type is the pointer, because switching pointer is much quicker if the size of element is very big. Modify the above example: 

  1. package main
  3. import (
  4.     "fmt"
  5.     "sort"
  6. )
  8. type command struct  {
  9.     name string
  10.     help string
  11. }
  13. type byName []*command
  15. func (a byName) Len() int           { return len(a) }
  16. func (a byName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
  17. func (a byName) Less(i, j int) bool { return a[i].name < a[j].name }
  19. func main() {
  20.     c := []*command{
  21.         {"breakpoint", "Set breakpoints"},
  22.         {"help", "Show help"},
  23.         {"args", "Print arguments"},
  24.         {"continue", "Continue"},
  25.     }
  26.     fmt.Println("Before sorting: ", c)
  27.     sort.Sort(byName(c))
  28.     fmt.Println("After sorting: ", c)
  29. }

Check the executing result: 

  1. Before sorting:  [0xc0820066a0 0xc0820066c0 0xc0820066e0 0xc082006700]
  2. After sorting:  [0xc0820066e0 0xc0820066a0 0xc082006700 0xc0820066c0]

You can see the pointers are reordered.

Reference:
The Go Programming Language.