深入理解Go语言中的自定义函数类型

type By func(p1, p2 *Planet) bool

package main

import (
    "fmt"
    "sort"
)

// Planet 结构体定义
type Planet struct {
    Name string
    Mass float64 // 质量，单位：地球质量
}

// String 方法使得Planet在打印时更具可读性
func (p Planet) String() string {
    return fmt.Sprintf("{Name: %s, Mass: %.2f}", p.Name, p.Mass)
}

// By 定义了一个用于比较两个Planet指针的函数类型
// 它的作用是判断p1是否“小于”p2，以决定排序顺序
type By func(p1, p2 *Planet) bool

// PlanetSlice 实现了sort.Interface接口，以便我们可以使用Go的sort包进行排序
type PlanetSlice []*Planet

func (s PlanetSlice) Len() int           { return len(s) }
func (s PlanetSlice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

// Less 方法接受一个By类型的函数作为参数，实现动态排序
func (s PlanetSlice) Less(i, j int) bool {
    // 假设我们有一个默认的排序逻辑，或者通过外部传入的By函数来决定
    // 在实际使用中，我们会将By函数作为PlanetSlice的一个字段或构造函数参数
    // 这里为了演示，我们假设Less方法内部会调用某个By函数
    // 实际sort包的By类型通常是这样使用的：
    // type sortablePlanets struct {
    //     PlanetSlice
    //     by By // 将By函数作为结构体字段
    // }
    // func (s sortablePlanets) Less(i, j int) bool {
    //     return s.by(s.PlanetSlice[i], s.PlanetSlice[j])
    // }

    // 为了简化示例，我们直接在Less方法中模拟一个比较逻辑
    // 实际应用中，By函数会被传入并存储，然后在这里调用
    // 假设我们有一个全局的或传入的比较器
    return s[i].Mass < s[j].Mass // 默认按质量升序
}

// ----------------------------------------------------------------------
// 演示如何使用自定义函数类型By
// ----------------------------------------------------------------------

// SortByName 是一个符合By签名的函数，用于按名称升序排序
func SortByName(p1, p2 *Planet) bool {
    return p1.Name < p2.Name
}

// SortByMass 是一个符合By签名的函数，用于按质量降序排序
func SortByMassDesc(p1, p2 *Planet) bool {
    return p1.Mass > p2.Mass // 降序
}

func main() {
    planets := []*Planet{
        {"Earth", 1.0},
        {"Mars", 0.11},
        {"Jupiter", 317.8},
        {"Venus", 0.82},
    }

    fmt.Println("原始行星列表:", planets)

    // 1. 声明一个By类型的变量，并赋值一个符合签名的函数
    var nameSorter By = SortByName
    fmt.Printf("nameSorter 的类型是: %T\n", nameSorter) // 输出: main.By

    // 2. 使用nameSorter进行比较
    fmt.Printf("地球是否小于火星 (按名称)? %t\n", nameSorter(planets[0], planets[1])) // Earth < Mars

    // 3. 演示如何将By类型作为参数传递给一个通用排序函数 (模拟sort.Sort)
    // 实际sort包中，By类型通常是作为匿名字段嵌入到实现sort.Interface的结构体中
    // 这里我们创建一个临时的可排序结构体来演示
    type sortablePlanets struct {
        planets []*Planet
        less    By // 将By函数作为字段
    }

    // 实现sort.Interface接口
    func (s sortablePlanets) Len() int           { return len(s.planets) }
    func (s sortablePlanets) Swap(i, j int)      { s.planets[i], s.planets[j] = s.planets[j], s.planets[i] }
    func (s sortablePlanets) Less(i, j int) bool { return s.less(s.planets[i], s.planets[j]) }

    // 按名称排序
    nameSortedPlanets := sortablePlanets{
        planets: planets,
        less:    SortByName, // 传入按名称排序的函数
    }
    sort.Sort(nameSortedPlanets)
    fmt.Println("按名称排序后:", nameSortedPlanets.planets)

    // 按质量降序排序
    massDescSortedPlanets := sortablePlanets{
        planets: planets, // 注意：这里planets已经被按名称排序了，为了演示，最好复制一份
        less:    SortByMassDesc, // 传入按质量降序排序的函数
    }
    // 为了避免修改原始切片，我们复制一份
    planetsCopy := make([]*Planet, len(planets))
    copy(planetsCopy, planets)
    massDescSortedPlanets.planets = planetsCopy

    sort.Sort(massDescSortedPlanets)
    fmt.Println("按质量降序排序后:", massDescSortedPlanets.planets)

    // 4. 理解 new(By) 的类型
    // new(By) 返回一个指向By类型零值的指针
    // 对于函数类型，其零值是 nil
    ptrToBy := new(By)
    fmt.Printf("new(By) 的类型是: %T, 值为: %v\n", ptrToBy, ptrToBy) // 输出: *main.By, <nil>
}