Go语言中函数类型的定义与应用

type NewTypeName func(parameter1 Type1, parameter2 Type2) ReturnType

package main

import (
    "fmt"
    "sort" // 引入sort包以便后续演示
)

// Planet 结构体定义
type Planet struct {
    Name string
    Mass float64 // 质量，例如以公斤为单位
}

// By 是一个函数类型，定义了比较两个 Planet 指针的顺序
type By func(p1, p2 *Planet) bool

// 为了让 Planet 切片能够使用 sort.Sort 接口，我们需要实现 sort.Interface
// type Interface interface {
//  Len() int
//  Less(i, j int) bool
//  Swap(i, j int)
// }

// planets 是 Planet 切片的别名，用于实现 sort.Interface
type planets []*Planet

func (p planets) Len() int {
    return len(p)
}

// Less 方法将使用我们定义的 By 函数类型来进行实际比较
// 注意：这里的 less 是一个 By 类型的字段，它存储了具体的比较逻辑
func (p planets) Less(i, j int) bool {
    // 这里的 p.less 实际上是我们需要在外部设置的 By 类型的函数
    // 为了演示方便，我们这里直接使用一个默认的或由外部传入的比较器
    // 实际应用中，通常会通过一个结构体来封装 By 函数，如下面的 exampleSorter
    // 这里我们暂时使用一个占位符，后面会展示如何正确使用 By 类型
    return p[i].Name < p[j].Name // 默认按名称排序，稍后会改进
}

func (p planets) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

// exampleSorter 结构体封装了 By 函数，使其可以作为 sort.Interface 使用
type exampleSorter struct {
    planets []*Planet
    by      By // 存储了具体的比较逻辑
}

func (s exampleSorter) Len() int {
    return len(s.planets)
}

func (s exampleSorter) Less(i, j int) bool {
    return s.by(s.planets[i], s.planets[j]) // 调用 By 类型存储的函数
}

func (s exampleSorter) Swap(i, j int) {
    s.planets[i], s.planets[j] = s.planets[j], s.planets[i]
}

// SortPlanets 是一个通用的排序函数，它接受一个 By 类型的比较器
func SortPlanets(p []*Planet, by By) {
    sorter := exampleSorter{
        planets: p,
        by:      by,
    }
    sort.Sort(sorter)
}

// sortByMassAsc 按照质量升序排列
func sortByMassAsc(p1, p2 *Planet) bool {
    return p1.Mass < p2.Mass
}

// sortByNameDesc 按照名称降序排列
func sortByNameDesc(p1, p2 *Planet) bool {
    return p1.Name > p2.Name // 注意这里是 > 实现降序
}

func main() {
    planetsData := []*Planet{
        {Name: "Earth", Mass: 5.972e24},
        {Name: "Mars", Mass: 0.6417e24},
        {Name: "Jupiter", Mass: 1.898e27},
        {Name: "Venus", Mass: 4.867e24},
    }

    fmt.Println("原始行星数据:")
    for _, p := range planetsData {
        fmt.Printf("  %s (%.2e kg)\n", p.Name, p.Mass)
    }
    fmt.Println("--------------------")

    // 1. 声明一个 By 类型的变量
    var massSorter By

    // 2. 将 sortByMassAsc 函数赋值给 massSorter 变量
    massSorter = sortByMassAsc

    // 使用 massSorter 对行星数据进行排序
    SortPlanets(planetsData, massSorter)
    fmt.Println("按质量升序排序后:")
    for _, p := range planetsData {
        fmt.Printf("  %s (%.2e kg)\n", p.Name, p.Mass)
    }
    fmt.Println("--------------------")

    // 3. 也可以直接将匿名函数赋值给 By 类型的变量
    // 按照名称升序排序
    nameSorter := func(p1, p2 *Planet) bool {
        return p1.Name < p2.Name
    }
    SortPlanets(planetsData, nameSorter)
    fmt.Println("按名称升序排序后:")
    for _, p := range planetsData {
        fmt.Printf("  %s (%.2e kg)\n", p.Name, p.Mass)
    }
    fmt.Println("--------------------")

    // 4. 验证类型
    // 打印 By 类型变量的类型
    fmt.Printf("变量 'massSorter' 的类型是: %T\n", massSorter)

    // 打印 new(By) 的类型。new 关键字返回指向零值的指针。
    // By 的零值是 nil 函数，所以 new(By) 返回的是 *By 类型的指针。
    fmt.Printf("new(By) 的类型是: %T\n", new(By))
}

原始行星数据:
  Earth (5.97e+24 kg)
  Mars (6.42e+23 kg)
  Jupiter (1.90e+27 kg)
  Venus (4.87e+24 kg)
--------------------
按质量升序排序后:
  Mars (6.42e+23 kg)
  Venus (4.87e+24 kg)
  Earth (5.97e+24 kg)
  Jupiter (1.90e+27 kg)
--------------------
按名称升序排序后:
  Earth (5.97e+24 kg)
  Jupiter (1.90e+27 kg)
  Mars (6.42e+23 kg)
  Venus (4.87e+24 kg)
--------------------
变量 'massSorter' 的类型是: main.By
new(By) 的类型是: *main.By