How Can I Efficiently Sort a Go Struct Array by a Custom Field?

Elegant Array Sorting in Go with Custom Field Comparators

Sorting an array of structs by a specific field can be a common task in Go programming. Let's explore an efficient and customizable way to achieve this.

The Problem:

Given an array of structs like the following:

type Planet struct {
    Name       string  `json:"name"`
    Aphelion   float64 `json:"aphelion"`   // in million km
    Perihelion float64 `json:"perihelion"` // in million km
    Axis       int64   `json:"Axis"`       // in km
    Radius     float64 `json:"radius"`
}

How can we sort this array by the Axis field?

The Solution:

Since Go 1.8, the sort.Slice function provides a convenient way to sort a slice using a custom comparison function. To sort the array of planets by Axis, we can use the following code:

import "sort"

// Define a comparison function to compare planets by their Axis value.
var sortByAxis = func(i, j int) bool {
    return planets[i].Axis < planets[j].Axis
}

// Create a slice over the array and sort it using the custom comparison function.
sort.Slice(planets[:], sortByAxis)

Using Arrays vs. Slices:

Normally, it's recommended to use slices over arrays in Go because slices are more flexible and efficient. However, in this case, the planets variable is declared as an array. To make it work with sort.Slice, we need to overlay it with a slice using planets[:].

Sorting and Maintaining the Array Structure:

It's important to note that the sorting operation modifies the array in place. If you wish to maintain the original array structure, you can create a copy of the slice before sorting:

planetSlice := make([]Planet, len(planets))
copy(planetSlice, planets)
sort.Slice(planetSlice, sortByAxis)

This allows you to use the sorted slice without affecting the original array.

The above is the detailed content of How Can I Efficiently Sort a Go Struct Array by a Custom Field?. For more information, please follow other related articles on the PHP Chinese website!