sort.Interface接口
排序操作和字符串格式化一样是很多程序经常使用的操作。尽管一个最短的快排程序只要 15 行就可以搞定，但是一个健壮的实现需要更多的代码，并且我们不希望每次我们需要的时候都重写或者拷贝这些代码。
幸运的是，sort 包内置的提供了根据一些排序函数来对任何序列排序的功能。它的设计非常独到。在很多语言中，排序算法都是和序列数据类型关联，同时排序函数和具体类型元素关联。相比之下，Go 语言的 sort.Sort 函数不会对具体的序列和它的元素做任何假设。相反，它使用了一个接口类型 sort.Interface 来指定通用的排序算法和可能被排序到的序列类型之间的约定。这个接口的实现由序列的具体表示和它希望排序的元素决定，序列的表示经常是一个切片。
一个内置的排序算法需要知道三个东西：序列的长度，表示两个元素比较的结果，一种交换两个元素的方式；这就是 sort.Interface 的三个方法：
package sort
type Interface interface {
Len() int
Less(i, j int) bool // i, j are indices of sequence elements
Swap(i, j int)
}为了对序列进行排序，我们需要定义一个实现了这三个方法的类型，然后对这个类型的一个实例应用 sort.Sort 函数。思考对一个字符串切片进行排序，这可能是最简单的例子了。下面是这个新的类型 StringSlice 和它的 Len，Less 和 Swap 方法：
type StringSlice []string
func (p StringSlice) Len() int { return len(p) }
func (p StringSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p StringSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }现在我们可以通过像下面这样将一个切片转换为一个 StringSlice 类型来进行排序：
sort.Sort(StringSlice(names))这个转换得到一个相同长度，容量，和基于 names 数组的切片值；并且这个切片值的类型有三个排序需要的方法。
对字符串切片的排序是很常用的需要，所以 sort 包提供了 StringSlice 类型，也提供了 Strings 函数能让上面这些调用简化成 sort.Strings(names) 。
这里用到的技术很容易适用到其它排序序列中，例如我们可以忽略大小写或者含有的特殊字符。（本书使用 Go 程序对索引词和页码进行排序也用到了这个技术，对罗马数字做了额外逻辑处理。）对于更复杂的排序，我们使用相同的方法，但是会用更复杂的数据结构和更复杂地实现 sort.Interface 的方法。
我们会运行上面的例子来对一个表格中的音乐播放列表进行排序。每个 track 都是单独的一行，每一列都是这个 track 的属性像艺术家，标题，和运行时间。想象一个图形用户界面来呈现这个表格，并且点击一个属性的顶部会使这个列表按照这个属性进行排序；再一次点击相同属性的顶部会进行逆向排序。让我们看下每个点击会发生什么响应。
下面的变量 tracks 包含了一个播放列表。（One of the authors apologizes for the other author’s musical tastes.）每个元素都不是 Track 本身而是指向它的指针。尽管我们在下面的代码中直接存储 Tracks 也可以工作，sort 函数会交换很多对元素，所以如果每个元素都是指针而不是 Track 类型会更快，指针是一个机器字码长度而 Track 类型可能是八个或更多。
Unresolved include directive in modules/ROOT/pages/ch7/ch7-06.adoc - include::example$/ch7/sorting/main.go[]printTracks 函数将播放列表打印成一个表格。一个图形化的展示可能会更好点，但是这个小程序使用 text/tabwriter 包来生成一个列整齐对齐和隔开的表格，像下面展示的这样。注意到 *tabwriter.Writer 是满足 io.Writer 接口的。它会收集每一片写向它的数据；它的 Flush 方法会格式化整个表格并且将它写向 os.Stdout（标准输出）。
func printTracks(tracks []*Track) {
const format = "%v\t%v\t%v\t%v\t%v\t\n"
tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
fmt.Fprintf(tw, format, "Title", "Artist", "Album", "Year", "Length")
fmt.Fprintf(tw, format, "-----", "------", "-----", "----", "------")
for _, t := range tracks {
fmt.Fprintf(tw, format, t.Title, t.Artist, t.Album, t.Year, t.Length)
}
tw.Flush() // calculate column widths and print table
}为了能按照 Artist 字段对播放列表进行排序，我们会像对 StringSlice 那样定义一个新的带有必须的 Len，Less 和 Swap 方法的切片类型。
type byArtist []*Track
func (x byArtist) Len() int { return len(x) }
func (x byArtist) Less(i, j int) bool { return x[i].Artist < x[j].Artist }
func (x byArtist) Swap(i, j int) { x[i], x[j] = x[j], x[i] }为了调用通用的排序程序，我们必须先将 tracks 转换为新的 byArtist 类型，它定义了具体的排序：
sort.Sort(byArtist(tracks))在按照 artist 对这个切片进行排序后，printTrack 的输出如下
Title Artist Album Year Length
----- ------ ----- ---- ------
Go Ahead Alicia Keys As I Am 2007 4m36s
Go Delilah From the Roots Up 2012 3m38s
Ready 2 Go Martin Solveig Smash 2011 4m24s
Go Moby Moby 1992 3m37s如果用户第二次请求“按照artist排序”，我们会对 tracks 进行逆向排序。然而我们不需要定义一个有颠倒 Less 方法的新类型 byReverseArtist，因为 sort 包中提供了 Reverse 函数将排序顺序转换成逆序。
sort.Sort(sort.Reverse(byArtist(tracks)))在按照 artist 对这个切片进行逆向排序后，printTrack 的输出如下：
Title Artist Album Year Length
----- ------ ----- ---- ------
Go Moby Moby 1992 3m37s
Ready 2 Go Martin Solveig Smash 2011 4m24s
Go Delilah From the Roots Up 2012 3m38s
Go Ahead Alicia Keys As I Am 2007 4m36ssort.Reverse 函数值得进行更近一步的学习，因为它使用了（§6.3）章中的组合，这是一个重要的思路。 sort 包定义了一个不公开的 struct 类型 reverse，它嵌入了一个 sort.Interface 。reverse的 Less 方法调用了内嵌的 sort.Interface 值的 Less 方法，但是通过交换索引的方式使排序结果变成逆序。
package sort
type reverse struct{ Interface } // that is, sort.Interface
func (r reverse) Less(i, j int) bool { return r.Interface.Less(j, i) }
func Reverse(data Interface) Interface { return reverse{data} }reverse 的另外两个方法 Len 和 Swap 隐式地由原有内嵌的 sort.Interface 提供。因为 reverse 是一个不公开的类型，所以导出函数 Reverse 返回一个包含原有 sort.Interface 值的 reverse 类型实例。
为了可以按照不同的列进行排序，我们必须定义一个新的类型例如 byYear：
type byYear []*Track
func (x byYear) Len() int { return len(x) }
func (x byYear) Less(i, j int) bool { return x[i].Year < x[j].Year }
func (x byYear) Swap(i, j int) { x[i], x[j] = x[j], x[i] }在使用 sort.Sort(byYear(tracks)) 按照年对 tracks 进行排序后，printTrack 展示了一个按时间先后顺序的列表：
Title Artist Album Year Length
----- ------ ----- ---- ------
Go Moby Moby 1992 3m37s
Go Ahead Alicia Keys As I Am 2007 4m36s
Ready 2 Go Martin Solveig Smash 2011 4m24s
Go Delilah From the Roots Up 2012 3m38s对于我们需要的每个切片元素类型和每个排序函数，我们需要定义一个新的 sort.Interface 实现。如你所见，Len 和 Swap 方法对于所有的切片类型都有相同的定义。下个例子，具体的类型 customSort 会将一个切片和函数结合，使我们只需要写比较函数就可以定义一个新的排序。顺便说下，实现了 sort.Interface 的具体类型不一定是切片类型；customSort 是一个结构体类型。
type customSort struct {
t []*Track
less func(x, y *Track) bool
}
func (x customSort) Len() int { return len(x.t) }
func (x customSort) Less(i, j int) bool { return x.less(x.t[i], x.t[j]) }
func (x customSort) Swap(i, j int) { x.t[i], x.t[j] = x.t[j], x.t[i] }让我们定义一个多层的排序函数，它主要的排序键是标题，第二个键是年，第三个键是运行时间 Length 。下面是该排序的调用，其中这个排序使用了匿名排序函数：
sort.Sort(customSort{tracks, func(x, y *Track) bool {
if x.Title != y.Title {
return x.Title < y.Title
}
if x.Year != y.Year {
return x.Year < y.Year
}
if x.Length != y.Length {
return x.Length < y.Length
}
return false
}})这下面是排序的结果。注意到两个标题是“Go”的 track 按照标题排序是相同的顺序，但是在按照 year 排序上更久的那个 track 优先。
Title Artist Album Year Length
----- ------ ----- ---- ------
Go Moby Moby 1992 3m37s
Go Delilah From the Roots Up 2012 3m38s
Go Ahead Alicia Keys As I Am 2007 4m36s
Ready 2 Go Martin Solveig Smash 2011 4m24s尽管对长度为 n 的序列排序需要 O(n log n) 次比较操作，检查一个序列是否已经有序至少需要 n-1 次比较。sort 包中的 IsSorted 函数帮我们做这样的检查。像 sort.Sort 一样，它也使用 sort.Interface 对这个序列和它的排序函数进行抽象，但是它从不会调用 Swap 方法：这段代码示范了 IntsAreSorted 和 Ints 函数在 IntSlice 类型上的使用：
values := []int{3, 1, 4, 1}
fmt.Println(sort.IntsAreSorted(values)) // "false"
sort.Ints(values)
fmt.Println(values) // "[1 1 3 4]"
fmt.Println(sort.IntsAreSorted(values)) // "true"
sort.Sort(sort.Reverse(sort.IntSlice(values)))
fmt.Println(values) // "[4 3 1 1]"
fmt.Println(sort.IntsAreSorted(values)) // "false"为了使用方便，sort 包为 []int、[]string 和 []float64 的正常排序提供了特定版本的函数和类型。对于其他类型，例如 []int64 或者 []uint，尽管路径也很简单，还是依赖我们自己实现。
练习 7.8： 很多图形界面提供了一个有状态的多重排序表格插件：主要的排序键是最近一次点击过列头的列，第二个排序键是第二最近点击过列头的列，等等。定义一个 sort.Interface 的实现用在这样的表格中。比较这个实现方式和重复使用 sort.Stable 来排序的方式。
练习 7.9： 使用 html/template 包（§4.6）替代 printTracks 将 tracks 展示成一个 HTML 表格。将这个解决方案用在前一个练习中，让每次点击一个列的头部产生一个 HTTP 请求来排序这个表格。
练习 7.10： sort.Interface 类型也可以适用在其它地方。编写一个 IsPalindrome(s sort.Interface) bool 函数表明序列s是否是回文序列，换句话说反向排序不会改变这个序列。假设如果 !s.Less(i, j) && !s.Less(j, i) 则索引 i 和 j 上的元素相等。