我正在尝试使用排序方法的两种变体:一种形式按名称对元素进行排序，另一种形式按薪水对元素进行排序。当我的 less 方法比较 whatever.salary 时，sort.Sort(people(data)) 起作用。如果我将它更改为 whatever.name，它也可以工作。我希望能够在 less 方法中专门调用这两个选项，如下面的代码所示。我的逻辑是使用 sort.Sort(people(data.name)) 作为姓名，使用 sort.Sort(people(data.salary)) 作为薪水。这些都不起作用。这甚至可以做到吗？

package main

import (
    "fmt"
    "sort"
)

type Comparable interface {
    Len()
    Less(i, j int) bool
    Swap(i, j int)
}

type person struct {
    name   string
    salary float64
}

func (a person) String() string {
    return fmt.Sprintf("%s: %g \n", a.name, a.salary)
}

type people []*person

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

func main() {

    var data = make(people, 10)

    var a, b, c, d, e, f, g, h, i, j person

    a.name, b.name, c.name, d.name, e.name, f.name,
        g.name, h.name, i.name, j.name = "Sheila Broflovski", "Ben Affleck",
        "Mr. Hankey", "Stan Marsh", "Kyle Broflovski", "Eric Cartman",
        "Kenny McCormick", "Mr. Garrison", "Matt Stone", "Trey Parker"

    a.salary, b.salary, c.salary, d.salary, e.salary, f.salary,
        g.salary, h.salary, i.salary, j.salary = 82000, 74000, 0, 400,
        2500, 1000, 4, 34000, 234000, 234000
    a.salary = 82000

    data[0] = &a
    data[1] = &b
    data[2] = &c
    data[3] = &d
    data[4] = &e
    data[5] = &f
    data[6] = &g
    data[7] = &h
    data[8] = &i
    data[9] = &j

    fmt.Println("\n\n\n")
    fmt.Print(data)
    sort.Sort(people(data))        //This works even with the two return statements
    sort.Sort(people(data.name))   //This does not work. Exist, a version that does?
    sort.Sort(people(data.salary)) //This does not work. Exist, a version that does?
    fmt.Println("\n\n\n")
    fmt.Print(data)
}

最佳答案

引入排序方法的常用方法是使用描述排序条件的新类型。这里是 byName 和 bySalary。然后您可以使用 sort.Sort(byName(data)) 进行排序。

这是一些演示代码。 Go 在构建数据结构方面也非常有用(例如在表驱动测试中大量使用)，这也可以帮助在这里构建您的人员数据。

package main

import "fmt"
import "sort"

type person struct {
    Name   string
    Salary float64
}

type people []*person

type byName people
type bySalary people

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

func (p bySalary) Len() int           { return len(p) }
func (p bySalary) Less(i, j int) bool { return p[i].Salary < p[j].Salary }
func (p bySalary) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

func main() {
    p := people{
        {"Sheila Broflovski", 82000},
        {"Ben Affleck", 74000},
        {"Mr. Hankey", 0},
        {"Stan Marsh", 400},
        {"Kyle Broflovski", 2500},
        {"Eric Cartman", 1000},
        {"Kenny McCormick", 4},
        {"Mr. Garrison", 34000},
        {"Matt Stone", 234000},
        {"Trey Parker", 234000},
    }
    fmt.Println("by name")
    sort.Sort(byName(p))
    for _, x := range p {
        fmt.Println(*x)
    }
    fmt.Println("by salary")
    sort.Sort(bySalary(p))
    for _, x := range p {
        fmt.Println(*x)
    }
}

关于sorting - 在 Go 中，当使用多个 return 语句时，如何调用每个特定的 return 语句？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21808237/