ch7/ch7-06 #153

2022-12-16T17:47:54Z

giscus[bot]
bot Dec 16, 2022

ch7/ch7-06

中文版

https://golang-china.github.io/gopl-zh/ch7/ch7-06.html

dugulingping · 2022-12-16T17:47:56Z

dugulingping
Dec 16, 2022 — with giscus

练习7.8

// 1. 定义数据类型
type Person struct {
	Name string
	Age  int
	Sex  bool
	ID   int
}

type PersonSlice []Person

// Less 没有实现sort.Interface的Less方法
func (p PersonSlice) Less(i, j int, field string) bool {
	return PersonByField(p[i], p[j], field)
}

// PersonByField 按照字段排序
func PersonByField(i, j Person, field string) bool {
	switch field {
	case "Name":
		return i.Name > j.Name
	case "Age":
		return i.Age < j.Age
	case "Sex":
		return i.Sex != j.Sex
	case "ID":
		return i.ID < j.ID
	}
	return false
}
func main() {
	// 构建数据
	data := PersonSlice{
		{"a", 1, true, 1},
		{"b", 2, false, 2},
		{"c", 3, true, 3},
		{"d", 4, false, 4},
		{"e", 5, true, 5},
		{"f", 6, false, 6},
		{"g", 7, true, 7},
	}
	// 排序
	sort.Slice(data, func(i, j int) bool {
		return data.Less(i, j, "Sex")
	})
	// 输出
	for _, v := range data {
		fmt.Println(v)
	}

	// 尝试使用反射解决，可是发现不会，233333
	t, b := reflect.TypeOf(data[1]).FieldByName("Name")
	fmt.Println(t, b)
}

0 replies

dugulingping · 2022-12-17T05:35:59Z

dugulingping
Dec 17, 2022 — with giscus

练习7.9

文件 /Practice/7.9.go

package main

import (
	"Study/src/study/day9Interface/Practice/comm"
	"html/template"
	"log"
	"net/http"
	"os"
	"sort"
)

//  使用html/template包（§4.6）替代printTracks将tracks展示成一个HTML表格。
//  将这个解决方案用在前一个练习中，让每次点击一个列的头部产生一个HTTP请求来排序这个表格。

const TEMPL = `
<!DOCTYPE html>
<html>
<head>
	<meta charset="UTF-8">
	<title>Document</title>
</head>
<body>
	<!--额加个边框吧-->
	<table border="1" cellspacing="0">
		<tr>
			<th><a href="/?sort=Name">Name</a></th>
			<th><a href="/?sort=Age">Age</a></th>
			<th><a href="./?sort=Sex">Sex</a></th>
			<th><a href="./?sort=ID">ID</a></th>
		</tr>
		{{range .}}
		<tr>
			<td>{{.Name}}</td>
			<td>{{.Age}}</td>
			<td>{{.Sex}}</td>
			<td>{{.ID}}</td>
		</tr>
		{{end}}
	</table>
</body>
</html>
`

func main() {
	// 构建数据
	data := comm.PersonSlice{
		{"a", 1, true, 1},
		{"b", 2, false, 2},
		{"c", 3, true, 3},
		{"d", 4, false, 4},
		{"e", 5, true, 5},
		{"f", 6, false, 6},
		{"g", 7, true, 7},
	}
	// 构建模版
	templ, err := template.New("test").Parse(TEMPL)
	if err != nil {
		log.Fatalln(err)
	}
	templ.Execute(os.Stdout, data)
	// 注册web
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// 排序
		sort.Slice(data, func(i, j int) bool {
			// 获得sort参数
			return data.Less(i, j, r.FormValue("sort"))
		})
		// 输出
		templ.Execute(w, data)
	})
	// 监听
	http.ListenAndServe(":8080", nil)
}

文件 /Practice/comm/comm.go

package comm

type Person struct {
	Name string
	Age  int
	Sex  bool
	ID   int
}

type PersonSlice []Person

// Less 没有实现sort.Interface的Less方法
func (p PersonSlice) Less(i, j int, field string) bool {
	return PersonByField(p[i], p[j], field)
}

// PersonByField 按照字段排序
func PersonByField(i, j Person, field string) bool {
	switch field {
	case "Name":
		return i.Name > j.Name
	case "Age":
		return i.Age < j.Age
	case "Sex":
		return i.Sex != j.Sex
	case "ID":
		return i.ID < j.ID
	}
	return false
}

0 replies

dugulingping · 2022-12-17T06:10:25Z

dugulingping
Dec 17, 2022 — with giscus

练习 7.10

package main

import (
	"fmt"
	"sort"
	"strings"
)

func IsPalindrome(s sort.Interface) bool {
	for i, j := 0, s.Len()-1; i < j; i, j = i+1, j-1 {
		if s.Less(i, j) || s.Less(j, i) {
			return false
		}
	}
	return true
}

func StrToSlice(str string) []string {
	return strings.Split(str, "")
}

func IntToSlice(num int) []int {
	var s []int
	for num > 0 {
		s = append(s, num%10)
		num /= 10
	}
	return s
}

func main() {
	var str = "abcdcba"
	// 将字符串转为[]string
	s := StrToSlice(str)
	fmt.Println(str, ":", IsPalindrome(sort.StringSlice(s))) // abcdcba : true

	var num = 123321
	// 将数字转为[]int
	nums := IntToSlice(num)
	fmt.Println(num, ":", IsPalindrome(sort.IntSlice(nums))) // 123321 : true

	num = 123456
	nums = IntToSlice(num)
	fmt.Println(num, ":", IsPalindrome(sort.IntSlice(nums))) // 123456 : false
}

0 replies

zhangbest5 · 2023-01-13T04:00:13Z

zhangbest5
Jan 13, 2023 — with giscus

真是理解不了

0 replies

FanXieGangN · 2023-01-18T14:42:26Z

FanXieGangN
Jan 18, 2023 — with giscus

[]int没有实现sort.Interface, 而sort.Reverse要求参数是sort.Interface类型，因此需要用其内置的IntSlice类型包装一下。上面的sort.Ints本质上也是如此，函数内部自动对[]int类型进行了包装。sort.IntsAreSorted也是用sort.IntSlice类型对传入的[]int类型进行一层包装，然后再调用IntSlice的Less函数进行比较的，默认是从小到大的顺序。

0 replies

weyg0 · 2023-04-26T02:12:14Z

weyg0
Apr 26, 2023 — with giscus

机器翻译痕迹太重了

0 replies

xianren68 · 2023-07-24T06:46:55Z

xianren68
Jul 24, 2023 — with giscus

7.10

package main

import (
	"fmt"
	"sort"
)

func main() {
	// 测试
	t1 := []int{1, 2, 3, 2, 1}
	fmt.Println(isPalindrome(sort.IntSlice(t1)))
	t2 := []string{"hello", "world", "hello"}
	fmt.Println(isPalindrome(sort.StringSlice(t2)))
	t3 := []string{"hello", "world", "hell"}
	fmt.Println(isPalindrome(sort.StringSlice(t3)))
}
func isPalindrome(s sort.Interface) bool {
	for i, j := 0, s.Len()-1; i < j; i, j = i+1, j-1 {
		// 两边依次比较，有不同则跳出
		if s.Less(i, j) || s.Less(j, i) {
			return false
		}
	}
	return true
}

0 replies

MHandZQ · 2024-03-10T10:07:48Z

MHandZQ
Mar 10, 2024 — with giscus

// Reverse returns the reverse order for data.
func Reverse(data Interface) Interface {
return &reverse{data}
}
想问一下，Reverse返回不会报类型不一致的错误吗？&reverse{data}是结构体指针，Reverse返回的是Interface类型

3 replies

xianren68 Mar 10, 2024 — with giscus

不会，go语言方法定义在结构体本身上时，会自动生成对应指针的方法，所以指针上也有这些方法，所以也实现了接口，类型是没问题的。

MHandZQ Mar 16, 2024 — with giscus

type reverse struct {
// This embedded Interface permits Reverse to use the methods of
// another Interface implementation.
Interface
}

// Less returns the opposite of the embedded implementation's Less method.
func (r reverse) Less(i, j int) bool {
return r.Interface.Less(j, i)
}

// Reverse returns the reverse order for data.
func Reverse(data Interface) Interface {
return &reverse{data}
}
好的谢谢，再请教个问题哈，我看sort包中这个Reverse函数返回的类型是Interface类型，但是函数内部返回的是结构体类型，这里不会类型不匹配吗？

xianren68 Mar 16, 2024

实现了接口所有方法的结构体/指针，可以隐式转换为接口类型

coderZoe · 2024-06-10T14:36:38Z

coderZoe
Jun 10, 2024 — with giscus

这个接口的设计还是挺奇怪的

Less(i, j int) bool

比较功能设计的入参不是两个元素相比较，而是两个index，这相当于从一开始就默认了需要排序的集合是数组或slice，这样才能通过index拿到具体元素
但既然都是数组或者slice了，又单独需要实现Swap

func (x customSort) Swap(i, j int)

实际上对于slice或数组，它的swap只能是下面这样吧

{ x.t[i], x.t[j] = x.t[j], x.t[i] }

我感觉这种别扭的设计是因为golang没在一开始引入泛型的原因，要是引入了泛型，比较接口应该设计为：

Less(this,that T) bool

6 replies

coderZoe Jun 10, 2024 — with giscus

还是有些不同的，首先我觉得想排序一个集合，只要这个集合是可迭代的就可以，既然是个可迭代集合，就不一定有索引的概念，如链表。即使有索引的概念，索引的类型也不一定是int，如map。其次，我没太理解您说的后半部分

swap交换如果自定义了一个很奇怪的类型，比较的序列在结构体嵌套很深的地方，那代码肯定不是一样的呀

不太理解这个要排序的元素结构复杂和swap有什么关系，既然已经限定了是slice或数组，那swap不就剩交换两个元素位置了吗

当然上面也只是一些个人的感觉，现实中链表和map很少会用到排序就是了，只是觉得功能既然是Sort，设计的时候就默认了要排序的集合结构有些奇怪。

xianren68 Jun 11, 2024

一般排序算法也是通过数组来实现的，所以排序一般就是对数组来说的，而且map之类的排序也没什么意义，后面这部分感觉你没有理解这个接口的含义，它是给自定义类型进行排序的，看下面这个例子

type one struct {
	name string
	age  int
}

type Test1 []one

func (t Test1) Len() int {
	return len(t)
}

func (t Test1) Less(i, j int) bool {
	return t[i].age < t[j].age
}

func (t Test1) Swap(i, j int) {
	t[i], t[j] = t[j], t[i]
}

type Test2 struct {
	list []one
}

func (t Test2) Len() int {
	return len(t.list)
}

func (t Test2) Less(i, j int) bool {
	return t.list[i].age < t.list[j].age
}

func (t Test2) Swap(i, j int) {
	t.list[i], t.list[j] = t.list[j], t.list[i]
}

我给test1和test2都实现了排序的接口，它们都可以通过sort.Sort()排序，但它们的实现是不同的

coderZoe Jun 11, 2024

一般排序算法也是通过数组来实现的，所以排序一般就是对数组来说的，而且map之类的排序也没什么意义，后面这部分感觉你没有理解这个接口的含义，它是给自定义类型进行排序的，看下面这个例子
type one struct {
	name string
	age  int
}

type Test1 []one

func (t Test1) Len() int {
	return len(t)
}

func (t Test1) Less(i, j int) bool {
	return t[i].age < t[j].age
}

func (t Test1) Swap(i, j int) {
	t[i], t[j] = t[j], t[i]
}

type Test2 struct {
	list []one
}

func (t Test2) Len() int {
	return len(t.list)
}

func (t Test2) Less(i, j int) bool {
	return t.list[i].age < t.list[j].age
}

func (t Test2) Swap(i, j int) {
	t.list[i], t.list[j] = t.list[j], t.list[i]
}
我给test1和test2都实现了排序的接口，它们都可以通过sort.Sort()排序，但它们的实现是不同的

后半部分现在我理解了，感谢解惑

soondubu137 Jul 27, 2024 — with giscus

我认为或许是因为底层实现必须要随机访问迭代器。试想，如果想要在任何iterable上实现“native”的排序，这对有些数据结构（那些只有单/双向迭代器的数据结构）来说代价是非常高的。出于这个原因，没有实现更一般的（general）排序的必要。如果需要排序一个这样的数据结构，应该先将其转换成拥有随机访问迭代器的数组，在数组上排序，然后再reconstruct。比如Java，看上去它支持对LinkedList的排序，但底层也是先将LinkedList转换成array排序，再reconstruct成LinkedList的。Go没有这些内置数据结构，所以它也就只能提供这个bare-bones的排序实现。如果用户想要自定义这些数据结构并实现排序功能的话，就需要像Java那样写一个method来wrap around这个基于随机访问的排序。

soondubu137 Jul 27, 2024 — with giscus

所以，虽然程序员有自由去实现这些低效的“native”排序，但是从Go设计者的角度来说，他们并没有理由去支持（help with）这些实现，他们只需要提供高效的基于随机访问的实现。

hongjiala · 2025-04-16T15:19:46Z

hongjiala
Apr 16, 2025 — with giscus

7.8
package main

import (
	"fmt"
	"sort"
)

// 定义结构体表示表格中的一行数据
type Person struct {
	Name  string
	Age   int
	City  string
}

// 定义一个结构体类型，用于实现多重排序
type PersonList []Person

// 定义排序键和排序顺序
type SortOrder struct {
	Key   string
	Asc   bool
}

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

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

// 实现 sort.Interface 的 Less 方法，动态选择排序键
func (p PersonList) Less(i, j int) bool {
	// 可以根据传入的排序键进行选择
	// 假设我们有多个排序规则：Age, Name, City
	if order[0].Key == "Age" {
		if p[i].Age != p[j].Age {
			if order[0].Asc {
				return p[i].Age < p[j].Age
			}
			return p[i].Age > p[j].Age
		}
	}

	if order[0].Key == "Name" {
		if p[i].Name != p[j].Name {
			if order[0].Asc {
				return p[i].Name < p[j].Name
			}
			return p[i].Name > p[j].Name
		}
	}

	if order[0].Key == "City" {
		if p[i].City != p[j].City {
			if order[0].Asc {
				return p[i].City < p[j].City
			}
			return p[i].City > p[j].City
		}
	}
	return true
}

var order = []SortOrder{
	{Key: "Age", Asc: true},
	{Key: "Name", Asc: true},
}

func main() {
	// 创建一些测试数据
	people := PersonList{
		{"John", 30, "New York"},
		{"Alice", 25, "Los Angeles"},
		{"Bob", 30, "Chicago"},
		{"Eve", 25, "Boston"},
		{"Charlie", 30, "New York"},
	}

	// 按多列进行排序
	sort.Sort(people)

	// 打印排序后的结果
	fmt.Println("Sorted people:")
	for _, p := range people {
		fmt.Printf("%s, %d, %s\n", p.Name, p.Age, p.City)
	}
}

0 replies

hongjiala · 2025-04-19T08:21:46Z

hongjiala
Apr 19, 2025 — with giscus

// 练习 7.10： sort.Interface类型也可以适用在其它地方。
// 编写一个IsPalindrome(s sort.Interface) bool函数表明序列s是否是回文序列，换句话说反向排序不会改变这个序列。假设如果!s.Less(i, j) && !s.Less(j, i)则索引i和j上的元素相等。
package main
import (
	"fmt"
	"sort"
)

// IsPalindrome 判断序列s是否是回文序列
func IsPalindrome(s sort.Interface) bool {
	n := s.Len()
	for i := 0; i < n/2; i++ {
		if !s.Less(i, n-i-1) && !s.Less(n-i-1, i) {
			return false
		}
	}
	return true
}

1 reply

GarenWoo Oct 12, 2025 — with giscus

判断条件你搞反了，按你的这个写法判断条件应当再取个非

w2807 · 2025-05-02T06:47:17Z

w2807
May 2, 2025 — with giscus

7.10

func IsPalindrome(s sort.Interface) bool {
	n := s.Len()
	i, j := 0, n-1
	for i < j {
		if !(!s.Less(i, j) && !s.Less(j, i)) {
			return false
		}
		i++
		j--
	}
	return true
}

0 replies

cheng470 · 2026-02-13T06:50:55Z

cheng470
Feb 13, 2026 — with giscus

package main

import (
	"fmt"
	"os"
	"reflect"
	"sort"
	"text/tabwriter"
	"time"
)

// 练习 7.8：
// 很多图形界面提供了一个有状态的多重排序表格插件：主要的排序键是最近一次点击过列头的列，第二个排序键是第二最近点击过列头的列，等等。
// 定义一个sort.Interface的实现用在这样的表格中。比较这个实现方式和重复使用sort.Stable来排序的方式。
type Track struct {
	Title  string
	Artist string
	Album  string
	Year   int
	Length time.Duration
}

func length(s string) time.Duration {
	d, err := time.ParseDuration(s)
	if err != nil {
		panic(s)
	}
	return d
}

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
}

// 多字段排序
type fieldsSort struct {
	t      []*Track
	fields []string
}

func (x fieldsSort) Len() int { return len(x.t) }
func (x fieldsSort) Less(i, j int) bool {
	o1, o2 := x.t[i], x.t[j]
	v1, v2 := reflect.ValueOf(o1), reflect.ValueOf(o2)
	t1 := reflect.TypeOf(o1)
	if t1.Kind() == reflect.Pointer {
		t1 = t1.Elem()
		v1 = v1.Elem()
		v2 = v2.Elem()
	}
	for _, fieldName := range x.fields {
		_, ok := t1.FieldByName(fieldName)
		if !ok {
			// 字段不存在，跳过（或者可以 panic 提示错误）
			continue
		}
		r1 := v1.FieldByName(fieldName)
		r2 := v2.FieldByName(fieldName)
		
		// 如果字段不可比较，跳过
		if !r1.IsValid() || !r2.IsValid() {
			continue
		}
		
		switch r1.Type().Kind() {
		case reflect.String:
			s1, s2 := r1.String(), r2.String()
			if s1 == s2 {
				continue
			}
			return s1 < s2
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			i1, i2 := r1.Int(), r2.Int()
			if i1 == i2 {
				continue
			}
			return i1 < i2
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			u1, u2 := r1.Uint(), r2.Uint()
			if u1 == u2 {
				continue
			}
			return u1 < u2
		case reflect.Float32, reflect.Float64:
			f1, f2 := r1.Float(), r2.Float()
			if f1 == f2 {
				continue
			}
			return f1 < f2
		case reflect.Bool:
			b1, b2 := r1.Bool(), r2.Bool()
			if b1 == b2 {
				continue
			}
			// false < true
			return !b1 && b2
		default:
			// 不支持的类型，跳过该字段
			// 可以考虑记录警告或返回错误
			continue
		}
	}
	// 所有字段都相等，返回 false（i 不小于 j）
	return false
}
func (x fieldsSort) Swap(i, j int) { x.t[i], x.t[j] = x.t[j], x.t[i] }

func main() {
	var tracks = []*Track{
		{"Go", "Delilah", "From the Roots Up", 2012, length("3m38s")},
		{"Go", "Moby", "Moby", 1992, length("3m37s")},
		{"Go Ahead", "Alicia Keys", "As I Am", 2007, length("4m36s")},
		{"Ready 2 Go", "Martin Solveig", "Smash", 2011, length("4m24s")},
	}
	sort.Sort(fieldsSort{tracks, []string{"Title", "Year"}})
	printTracks(tracks)
}

0 replies

ch7/ch7-06 #153

Uh oh!

giscus[bot] bot Dec 16, 2022

ch7/ch7-06

Replies: 13 comments · 10 replies

Uh oh!

dugulingping Dec 16, 2022 — with giscus

练习7.8

Uh oh!

dugulingping Dec 17, 2022 — with giscus

练习7.9

文件 /Practice/7.9.go

文件 /Practice/comm/comm.go

Uh oh!

dugulingping Dec 17, 2022 — with giscus

练习 7.10

Uh oh!

zhangbest5 Jan 13, 2023 — with giscus

Uh oh!

FanXieGangN Jan 18, 2023 — with giscus

Uh oh!

weyg0 Apr 26, 2023 — with giscus

Uh oh!

xianren68 Jul 24, 2023 — with giscus

7.10

Uh oh!

MHandZQ Mar 10, 2024 — with giscus

Uh oh!

xianren68 Mar 10, 2024 — with giscus

Uh oh!

MHandZQ Mar 16, 2024 — with giscus

Uh oh!

xianren68 Mar 16, 2024

Uh oh!

coderZoe Jun 10, 2024 — with giscus

Uh oh!

coderZoe Jun 10, 2024 — with giscus

Uh oh!

xianren68 Jun 11, 2024

Uh oh!

coderZoe Jun 11, 2024

Uh oh!

soondubu137 Jul 27, 2024 — with giscus

Uh oh!

soondubu137 Jul 27, 2024 — with giscus

Uh oh!

hongjiala Apr 16, 2025 — with giscus

Uh oh!

hongjiala Apr 19, 2025 — with giscus

Uh oh!

GarenWoo Oct 12, 2025 — with giscus

Uh oh!

w2807 May 2, 2025 — with giscus

Uh oh!

cheng470 Feb 13, 2026 — with giscus

giscus[bot]
bot Dec 16, 2022

Replies: 13 comments 10 replies

dugulingping
Dec 16, 2022 — with giscus

dugulingping
Dec 17, 2022 — with giscus

dugulingping
Dec 17, 2022 — with giscus

zhangbest5
Jan 13, 2023 — with giscus

FanXieGangN
Jan 18, 2023 — with giscus

weyg0
Apr 26, 2023 — with giscus

xianren68
Jul 24, 2023 — with giscus

MHandZQ
Mar 10, 2024 — with giscus

coderZoe
Jun 10, 2024 — with giscus

hongjiala
Apr 16, 2025 — with giscus

hongjiala
Apr 19, 2025 — with giscus

w2807
May 2, 2025 — with giscus

cheng470
Feb 13, 2026 — with giscus