关于sorting：Go：有没有一种方法可以避免执行完整sort.Interfaces的切片结构？

Go: Is there a way to avoid the implementation of the full sort.Interface for slices of structs?

如果我在Go中有一个数组的结构体/切片，并想使用sort包对它们进行排序，在我看来，我需要实现包含3个方法的整个sort接口：

伦
交换
减

无论数组中的struct类型如何，Len和Swap似乎始终应该具有相同的实现。

有没有一种方法可以避免每次都使用工具Len和Swap，或者这仅仅是Go语言中缺少泛型的限制？

如果您要对同一切片类型实施几种不同的比较操作，则可以使用嵌入来避免每次重新定义Len和Swap。您还可以使用此技术将参数添加到排序中，例如根据某些运行时值进行反向排序或不进行排序。

例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

package main

import (
"sort"
)

type T struct {
Foo int
Bar int
}

// TVector is our basic vector type.
type TVector []T

func (v TVector) Len() int {
return len(v)
}

func (v TVector) Swap(i, j int) {
v[i], v[j] = v[j], v[i]
}

// default comparison.
func (v TVector) Less(i, j int) bool {
return v[i].Foo < v[j].Foo
}

// TVectorBarOrdered embeds TVector and overrides
// its Less method so that it is ordered by the Bar field.
type TVectorBarOrdered struct {
TVector
}

func (v TVectorBarOrdered) Less(i, j int) bool {
return v.TVector[i].Bar < v.TVector[j].Bar
}

// TVectorArbitraryOrdered sorts in normal or reversed
// order depending on the order of its Reversed field.
type TVectorArbitraryOrdered struct {
Reversed bool
TVector
}

func (v TVectorArbitraryOrdered) Less(i, j int) bool {
if v.Reversed {
i, j = j, i
}
return v.TVector[i].Foo < v.TVector[j].Foo
}

func main() {
v := []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}
sort.Sort(TVector(v))
sort.Sort(TVectorBarOrdered{v})
sort.Sort(TVectorArbitraryOrdered{true, v})
}