Go语言中自定义结构体切片排序：基于sort.Interface的实现与应用

package main

import (
    "fmt"
    "sort"
    "time"
)

// Course 结构体定义，模拟从数据存储中获取的课程数据
type Course struct {
    Key         string    // 在GAE中通常是 *datastore.Key
    FormKey     string    // 在GAE中通常是 *datastore.Key
    Selected    bool
    User        string
    Name        string
    Description string
    Date        time.Time
}

// Courses 是 Course 结构体指针切片的别名，用于实现 sort.Interface
type Courses []*Course

// Len 实现 sort.Interface 的 Len 方法
func (s Courses) Len() int {
    return len(s)
}

// Swap 实现 sort.Interface 的 Swap 方法
func (s Courses) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

// ByName 是一个辅助类型，用于按 Name 字段进行排序
type ByName struct {
    Courses // 嵌入 Courses 切片
}

// Less 实现 sort.Interface 的 Less 方法，定义按 Name 字段升序排序
func (s ByName) Less(i, j int) bool {
    return s.Courses[i].Name < s.Courses[j].Name
}

func main() {
    // 示例数据
    var courses = Courses{
        &Course{Name: "John"},
        &Course{Name: "Peter"},
        &Course{Name: "Jane"},
        &Course{Name: "Alice"},
    }

    fmt.Println("原始顺序:")
    for _, course := range courses {
        fmt.Println(course.Name)
    }

    // 使用 sort.Sort 进行排序
    // 注意：这里传入的是 ByName{courses}，而不是 courses 本身
    sort.Sort(ByName{courses})

    fmt.Println("\n按 Name 排序后:")
    for _, course := range courses {
        fmt.Println(course.Name)
    }
}

原始顺序:
John
Peter
Jane
Alice

按 Name 排序后:
Alice
Jane
John
Peter

import (
    "context"
    "google.golang.org/appengine/datastore"
    "net/http"
    "time"
)

// courseData 结构体，与问题中保持一致
type courseData struct {
    Key         *datastore.Key
    FormKey     *datastore.Key
    Selected    bool
    User        string
    Name        string
    Description string
    Date        time.Time
}

// courseDataSlice 是 []*courseData 的别名
type courseDataSlice []*courseData

// 实现 Len 和 Swap 方法与上面的 Courses 类似
func (s courseDataSlice) Len() int      { return len(s) }
func (s courseDataSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// ByCourseName 是按 Name 字段排序的辅助类型
type ByCourseName struct {
    courseDataSlice
}

func (s ByCourseName) Less(i, j int) bool {
    return s.courseDataSlice[i].Name < s.courseDataSlice[j].Name
}

func fetchAndSortCourses(ctx context.Context, w http.ResponseWriter) {
    q := datastore.NewQuery("Course")
    var courses []*courseData // 获取到的数据是 []*courseData 类型

    // GetAll 会填充 courses 切片，并返回对应的 Key 列表
    if keys, err := q.GetAll(ctx, &courses); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    } else {
        // 如果需要，将 Key 赋值回结构体内部
        for i := range courses {
            courses[i].Key = keys[i]
        }
    }

    // 对获取到的 courses 切片进行排序
    // 注意这里需要将 []*courseData 转换为我们定义的 courseDataSlice 类型
    sort.Sort(ByCourseName{courseDataSlice(courses)})

    // 此时 courses 切片已经按 Name 字段排序
    // 可以在这里处理排序后的数据，例如渲染到HTML模板
    for _, course := range courses {
        fmt.Fprintf(w, "Course Name: %s\n", course.Name)
    }
}