按（任意）字段名对结构数组进行简单排序的最短方法是什么？

Question

我只是有一个问题，我有一个数组的结构，例如。

package main

import "log"

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"`
}

func main() {
    var mars = new(Planet)
    mars.Name = "Mars"
    mars.Aphelion = 249.2
    mars.Perihelion = 206.7
    mars.Axis = 227939100
    mars.Radius = 3389.5

    var earth = new(Planet)
    earth.Name = "Earth"
    earth.Aphelion = 151.930
    earth.Perihelion = 147.095
    earth.Axis = 149598261
    earth.Radius = 6371.0

    var venus = new(Planet)
    venus.Name = "Venus"
    venus.Aphelion = 108.939
    venus.Perihelion = 107.477
    venus.Axis = 108208000
    venus.Radius = 6051.8

    planets := [...]Planet{*mars, *venus, *earth}
    log.Println(planets)
}

假设您想按轴对其进行排序。你是怎么做到的？

（注：我看过http://golang.org/pkg/sort/，好像还能用，但光靠一个很简单的按键简单排序，就得加20行左右。我有一个Python背景，它是简单的排序（行星，key=lambda n： n。轴）-有类似的简单围棋吗？（




Answer 1

截至Go 1.8，@AndreKR的答案是更好的解决方案。

您可以实现实现排序接口的集合类型。

下面是两种类型的示例，允许您按轴或名称进行排序：

package main

import "log"
import "sort"

// AxisSorter sorts planets by axis.
type AxisSorter []Planet

func (a AxisSorter) Len() int           { return len(a) }
func (a AxisSorter) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a AxisSorter) Less(i, j int) bool { return a[i].Axis < a[j].Axis }

// NameSorter sorts planets by name.
type NameSorter []Planet

func (a NameSorter) Len() int           { return len(a) }
func (a NameSorter) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a NameSorter) Less(i, j int) bool { return a[i].Name < a[j].Name }

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"`
}

func main() {
    var mars Planet
    mars.Name = "Mars"
    mars.Aphelion = 249.2
    mars.Perihelion = 206.7
    mars.Axis = 227939100
    mars.Radius = 3389.5

    var earth Planet
    earth.Name = "Earth"
    earth.Aphelion = 151.930
    earth.Perihelion = 147.095
    earth.Axis = 149598261
    earth.Radius = 6371.0

    var venus Planet
    venus.Name = "Venus"
    venus.Aphelion = 108.939
    venus.Perihelion = 107.477
    venus.Axis = 108208000
    venus.Radius = 6051.8

    planets := []Planet{mars, venus, earth}
    log.Println("unsorted:", planets)

    sort.Sort(AxisSorter(planets))
    log.Println("by axis:", planets)

    sort.Sort(NameSorter(planets))
    log.Println("by name:", planets)
}

Answer 2

更新：此答案与较旧版本的go有关。对于Go 1.8和更新版本，请参见上面AndreKR的答案。

如果您想要比标准库sortpackage更简洁的东西，可以使用第三方github。com/bradfitz/slice软件包。它使用一些技巧来生成排序切片所需的Len和Swap方法，因此您只需要提供Less方法。

使用此软件包，您可以通过以下方式执行排序：

slice.Sort(planets[:], func(i, j int) bool {
    return planets[i].Axis < planets[j].Axis
})

planets[：]部件是生成覆盖阵列的切片所必需的。如果你制作了一个切片而不是一个数组，你可以跳过这个部分。

Answer 3

从Go 1.8开始，现在可以使用sort。切片对切片进行排序：

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

通常没有理由使用数组而不是切片，但是在您的示例中，您使用的是数组，因此您必须用切片覆盖它（添加[：]）以使其与排序一起工作。切片：

sort.Slice(planets[:], func(i, j int) bool {
  return planets[i].Axis < planets[j].Axis
})

排序会更改数组，因此如果确实需要，可以在排序后继续使用数组而不是切片。