# Go Cheatsheet - Sort

## Sort

### Sort Ints

```go
ints := []int{3, 1, 4, 5, 2}
sort.Ints(ints)
// [1 2 3 4 5]
```

### Sort String

```go
strs := []string{"bob", "clair", "alice"}
sort.Strings(strs)
// [alice bob clair]
```

### Sort in Reverse Order

```go
ints := []int{3, 1, 4, 5, 2}
sort.Sort(sort.Reverse(sort.IntSlice(ints)))
// [5 4 3 2 1]
```

### Sort with Custom Compare Function

```go
people := []map[string]interface{}{
	{"name": "bob", "age": 25},
	{"name": "alice", "age": 22},
	{"name": "elon", "age": 21},
	{"name": "david", "age": 24},
	{"name": "frank", "age": 21},
	{"name": "clair", "age": 21},
}

sort.Slice(people, func(i, j int) bool {
	return people[i]["age"].(int) > people[j]["age"].(int)
})
fmt.Println("Sorted People", people)
// [map[age:25 name:bob] map[age:24 name:david] map[age:22 name:alice] map[age:21 name:elon] map[age:21 name:frank] map[age:21 name:clair]]
```

Stable sort: `sort.SliceStable`, it will keep equal elements in their original order.

### Sort with Sort Interface

```go
type peopleByAge []map[string]interface{}

func (a peopleByAge) Len() int {
	return len(a)
}

func (a peopleByAge) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

func (a peopleByAge) Less(i, j int) bool {
	return a[i]["age"].(int) < a[j]["age"].(int)
}

people := []map[string]interface{}{
	{"name": "bob", "age": 25},
	{"name": "alice", "age": 22},
	{"name": "elon", "age": 21},
	{"name": "david", "age": 24},
	{"name": "frank", "age": 21},
	{"name": "clair", "age": 21},
}

sort.Sort(peopleByAge(people))
fmt.Println("Sorted People", people)
// [map[age:21 name:elon] map[age:21 name:frank] map[age:21 name:clair] map[age:22 name:alice] map[age:24 name:david] map[age:25 name:bob]]
```

Stable sort: `sort.Stable`, it will keep equal elements in their original order.

This sort with "Sort Interface" method is preferred compare to the "compare function" above, since the "compare function" method will use `reflect` which might slow down your sort.