JIYIK CN >

This article describes how to sort structure slices in Go.

GoLang sorting structure slices

GoLang provides two methods to sort a struct slice; one is sort.Sliceand the other is sort.SliceStable. We also need to use the less function with these two methods to sort a struct slice.

The syntax for these methods is:

//sort.Slice
func Slice(x StructSlice, less func(i, j int) bool)

//sort.SliceStable
func Slice(x StructSlice, less func(i, j int) bool)

Where x is a slice of structure and the slice will be sorted according to the less function. Let us try to implement some examples to understand how to sort a slice of structure in GoLang.

Sort a struct slice by field

Sorting a struct slice by field is a basic example of sorting a struct slice. We compare the value of one member of a struct slice with the value of another member of the same struct slice based on a field, let's see an example.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name   string
    Salary int
}

func main() {
    // Sort in Ascending order
    employees := []Employee{
        {Name: "John", Salary: 1500},
        {Name: "Joe", Salary: 3000},
        {Name: "Jack", Salary: 3400},
    }

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

    fmt.Println(employees)

    // Sort in Descending order
    employees1 := []Employee{
        {Name: "John", Salary: 1500},
        {Name: "Joe", Salary: 3000},
        {Name: "Jack", Salary: 3400},
    }

    sort.Slice(employees1, func(i, j int) bool {
        return employees1[i].Salary > employees1[j].Salary
    })

    fmt.Println(employees1)
}

The above code contains an Employee structure with two fields Name and Salary, then it creates a slice of the structure and sorts it in ascending order based on the field Salary using the Slice method, and then sorts another slice in descending order.

See the output:

[{John 1500} {Joe 3000} {Jack 3400}]
[{Jack 3400} {Joe 3000} {John 1500}]

Now we cannot use on these types of slices sort.SliceStablewhich include key-value pairs (maps) of field names and values. Using sort.SliceStable, we can sort simple slices of structures which contain only values.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name   string
    Salary int
}

func main() {
    // Sort in Ascending order
    employees := []Employee{
        {"John", 1500},
        {"Joe", 3000},
        {"Jack", 3400},
    }

    sort.SliceStable(employees, func(i, j int) bool {
        return employees[i].Salary < employees[j].Salary
    })

    fmt.Println(employees)

    // Sort in Descending order
    employees1 := []Employee{
        {"John", 1500},
        {"Joe", 3000},
        {"Jack", 3400},
    }

    sort.SliceStable(employees1, func(i, j int) bool {
        return employees1[i].Salary > employees1[j].Salary
    })

    fmt.Println(employees1)
}

The above code will similarly sort the struct slice based on the fields in the struct slice that do not have key-value pairs of name and value.

See the output:

[{John 1500} {Joe 3000} {Jack 3400}]
[{Jack 3400} {Joe 3000} {John 1500}]

Sort a struct slice by multiple fields

It is also possible to sort a slice of a structure by multiple fields. We have to extend the less function; let's take an example.

package main

import (
    "fmt"
    "sort"
)

type Employee struct {
    Name     string
    Position string
}

func main() {
    // Sort in Descending order
    employees := []Employee{
        {"Michael", "Developer"},
        {"Jack", "Manager"},
        {"Joe", "CEO"},
        {"Leonard", "Intern"},
        {"Sheldon", "Developer"},
    }

    sort.SliceStable(employees, func(i, j int) bool {
        if employees[i].Position != employees[j].Position {
            return employees[i].Position < employees[j].Position
        }

        return employees[i].Name < employees[j].Name
    })

    fmt.Println(employees)

    // Sort in Ascending order
    employees1 := []Employee{
        {"Michael", "Developer"},
        {"Jack", "Manager"},
        {"Joe", "CEO"},
        {"Leonard", "Intern"},
        {"Sheldon", "Developer"},
    }

    sort.SliceStable(employees1, func(i, j int) bool {
        if employees1[i].Position != employees1[j].Position {
            return employees1[i].Position > employees1[j].Position
        }

        return employees1[i].Name > employees1[j].Name
    })

    fmt.Println(employees1)
}

The above code will sort based on Name and Position, if two employees have same position then it will sort based on Name field. Slices of structure will be sorted in descending and ascending order.

See the output:

[{Joe CEO} {Michael Developer} {Sheldon Developer} {Leonard Intern} {Jack Manager}]
[{Jack Manager} {Leonard Intern} {Sheldon Developer} {Michael Developer} {Joe CEO}]