Go程序设计语言课后习题答案-第七章(接口)

第七章

接口即约定
接口类型
实现接口
使用flag.Value来解析参数
接口值
使用Sort.Interface来排序
http.Handler接口
error接口
示例: 表达式求值器
类型断言
使用类型断言来识别错误
通过接口类型断言来查询特性
类型分支
示例: 基于标记的XML解析
一些建议

这章是重点

练习7.1:

使用类似ByteCounter的想法,实现单词和行的计数器.实现时考虑使用bufio.ScanWords

创建一个结构体，实现Writer方法，分词得到写入的个数

package main

import (
	"fmt"
	"bufio"
	"strings"
)

type ByteCounter int

func (c *ByteCounter) Write(p []byte) (int, error) {
	scan := bufio.NewScanner(strings.NewReader(string(p)))
	scan.Split(bufio.ScanWords)

	for scan.Scan() {
		*c += 1
	}
	return len(p), nil
}

func main() {
	var c ByteCounter

	var name = "Dolly"
	fmt.Fprintf(&c, "hello, %s", name)
	fmt.Println(c)
}

练习7.2:

实现一个满足如下前面的CountingWriter函数,输入一个io.Writer,输出一个封装了输入值的新Writer,以及一个指向int64的指针,该指针对应的值是新的Writer写入的字节数
func CountingWriter(w io.Writer) (io.Writer, *int64)

这个地方使用了一个全局的变量统计写入的字节数，CountingWriter好像再外面封装了一层一样，仅仅只是为了记一个数，需要新建一个类型，然后让这个类型满足接口

package main

import "io"

var position int64

type Counting struct {
	W io.Writer
}

func (c *Counting) Write(p []byte) (n int, err error) {
	n, err = c.W.Write(p)
	position += int64(n)
	return n, err
}

func CountingWriter(w io.Writer) (io.Writer, *int64) {
	return &Counting{w}, &position
}

练习7.3:

为gopl.io/ch4/treesort中的*tree类型写一个String方法,用于展示其中的值序列

这个练习题比较直白了，估计是想说类型可以自己添加方法，这个地方直接使用广度优先保存下了列表然后打印一下

func (t *tree) String() string {
	var deque []*tree
	var ret []int
	deque = append(deque, t)
	for len(deque) > 0 {
		current := deque[0]
		deque = deque[1:]
		if current.left != nil {
			deque = append(deque, current.left)
		}
		if current.right != nil {
			deque = append(deque, current.right)
		}
		ret = append(ret, current.value)
	}

	var buf bytes.Buffer
	buf.Write([]byte("{"))
	for i, v := range ret {
		if i == len(ret)-1 {
			buf.Write([]byte(fmt.Sprintf("%d", v)))
		} else {
			buf.Write([]byte(fmt.Sprintf("%d, ", v)))
		}
	}
	buf.Write([]byte("}"))
	return buf.String()
}

练习7.4:

strings.NewReader函数输入一个字符串,返回一个从字符串读取数据并满足io.Reader接口的值.请自己实现该函数,并且通过它来让HTML分析器支持以字符串作为输入

Golang里面使用Newxxx这样的函数特别普遍，一个常用的套路，它初始化了一个struct，然后该结构体满足某接口

package main

import (
	"io"
	"io/ioutil"
	"fmt"
)

type S struct {
	R       string
	current int
}

func (s *S) Read(p []byte) (n int, err error) {
	if s.current >= len(s.R) {
		return 0, io.EOF
	}
	l := copy(p, s.R[s.current:])
	s.current = l
	return l, nil
}

func NewReader(s string) io.Reader {
	return &S{s, 0}
}


func main() {
	r := NewReader("123")
	s, err := ioutil.ReadAll(r)
	if err != nil {
		fmt.Println(s)
	}
	fmt.Println(string(s))
}

练习7.5:

io包中的LimitReader函数接受io.Reader r和字节数n,返回一个Reader,该返回值从r读取数据,但在读取n字节后报告文件结束.请实现该函数
func LimitReader(r io.Reader,n int64) io.Reader

感觉和上面的New差不多,只不过这个地方的初始化是使用了一个接口类型值

package main

import "io"

type LimitR struct {
	R io.Reader
	N int64
}

func (l *LimitR) Read(p []byte) (n int, err error) {
	if l.N <= 0 {
		return 0, io.EOF
	}
	if int64(len(p)) > l.N {
		p = p[0:l.N]
	}
	n, err = l.R.Read(p)
	l.N -= int64(n)
	return n, err
}

func LimitReader(r io.Reader, n int64) io.Reader {
	return &LimitR{r, n}
}

练习7.6:

在tempflag中支持热力学温度

这题没什么意义，添加一个case判断就可以了
本小节主要讲解了flag.Value的原理,先有一个struct结构体,然后一个函数xxFlag(name string,value Type,usage string) *Type
上述函数调用flag.CommandLine.Var进行注册，当调用flag.Parse的时候调用结构体相应的Set方法,达到了解析命令行参数的目的

练习7.7:

请解释为什么默认值20.0没有写单位,而在帮助消息中却包含单位

接上一题,因为除了String方法还有Set方法,查看帮助的时候会调用它,在celsiusFlag结构体中String方法直接添加了单位

练习7.8:

很多图形界面提供了一个表格空间,它支持有状态的多层排序,先按照最近单击的列表排序,接着是上一次单击的列,依次类推.请定义sort.Interface接口来实现如上需求,试比较这个方法和多次使用sort.Stable排序的异同

这一节主要讲利用接口实现排序,需要排序的对象提供三个方法Len、Swap、Less
用一个slice来维持状态，Less函数使用倒序遍历加上switch开实现
对比sort.Stable来说，sort.Stable是稳定排序，一个对象有A/B两个属性，当使用稳定排序的时候假如A属性值相同，则对象相对位置不会改变

代码可能写的有点失败~~

package main

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

type Track struct {
	Title  string
	Artist string
	Album  string
	Year   int
	Length time.Duration
}

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")},
}



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

type customSort struct {
	t []*Track
	r []string
}

var c = customSort{tracks,[]string{}}

func (x customSort) Len() int {
	return len(x.t)
}

func (x customSort) Less(i, j int) bool {
	for i := len(x.r) - 1; i >= 0; i-- {
		switch x.r[i] {
		case "Title":
			if x.t[i].Title != x.t[j].Title {
				return x.t[i].Title < x.t[j].Title
			}
		case "Artist":
			if x.t[i].Artist != x.t[j].Artist {
				return x.t[i].Artist < x.t[j].Artist
			}
		case "Album":
			if x.t[i].Artist != x.t[j].Artist {
				return x.t[i].Artist < x.t[j].Artist
			}
		case "Year":
			if x.t[i].Year != x.t[j].Year {
				return x.t[i].Year < x.t[j].Year
			}
		default:
			panic("Not support field")
		}
	}
	return false
}

func (x customSort) Swap(i, j int) {
	x.t[i], x.t[j] = x.t[j], x.t[i]
}


func Sort(s string){
	c.r = append(c.r,s)
	if len(c.r) > 4{
		c.r = c.r[:4]
	}
	sort.Sort(c)
}

func main()  {
	Sort("Title")
	for _,v := range tracks{
		fmt.Println(*v)
	}
	fmt.Println("=======")
	Sort("Artist")
	for _,v := range tracks{
		fmt.Println(*v)
	}
	fmt.Println("=======")
	Sort("Album")
	for _,v := range tracks{
		fmt.Println(*v)
	}
}

练习7.9:

利用html/template包来替换printTracks函数,使用HTML表格来显示音乐列表,结合上一个练习,来实现通过单击列头来发送HTTP请求,进而对表格排序

对这题完全没兴趣，可以练习写template包

练习7.10:

sort.Interface也可以用于其他用户.试写一个函数IsPalindrome(s sort.Interface)bool来判断一个序列是否是回文,即序列反转后保持不变.可以假定对于下标分别为i、j的元素,如果!s.Less(i,j)&&!s.Less(j,i),那么两个元素相等

左右向中间比较，都相等则表示为回文,主要是用接口方法的Len和Less判断是否相等

package main

import (
	"sort"
	"fmt"
)

type Demo []int

func (d Demo) Len() int {
	return len(d)
}

func (d Demo) Less(i, j int) bool {
	return d[i] < d[j]
}

func (d Demo) Swap(i, j int) {
	d[i], d[j] = d[j], d[i]
}

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

func main() {
	fmt.Println(IsPalindrome(Demo{1, 2, 1}))
	fmt.Println(IsPalindrome(Demo{1, 2, 3}))
}

练习7.11:

增加额外的处理程序,来支持创建、读取、更新和删除数据库条目.比如,/update?item=socks&prince=6 这样的请求将更新仓库中物品的价格,如果商品不存在或者价格无效就返回错误

使用多个http.HandleFunc
使用锁防止并发修改
给struct添加多个方法就好了

package main

import (
	"fmt"
	"log"
	"net/http"
	"sync"
	"strconv"
)

func main() {
	db := database{map[string]dollars{"shoes": 50, "socks": 5}, sync.Mutex{}}
	http.HandleFunc("/list", db.list)
	http.HandleFunc("/price", db.price)
	http.HandleFunc("/update", db.update)
	http.HandleFunc("/delete", db.delete)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

type dollars float32

func (d dollars) String() string { return fmt.Sprintf("$%.2f", d) }

type database struct {
	R     map[string]dollars
	mutex sync.Mutex
}

func (db database) list(w http.ResponseWriter, req *http.Request) {
	for item, price := range db.R {
		fmt.Fprintf(w, "%s: %s\n", item, price)
	}
}

func (db database) update(w http.ResponseWriter, req *http.Request) {
	db.mutex.Lock()
	defer db.mutex.Unlock()

	item := req.URL.Query().Get("item")
	price := req.URL.Query().Get("price")

	p, err := strconv.ParseFloat(price, 64)
	if err != nil {
		fmt.Fprint(w, "invalid price")
	} else {
		db.R[item] = dollars(p)
		fmt.Fprint(w, "Update price success")
	}
}

func (db database) delete(w http.ResponseWriter, req *http.Request) {
	db.mutex.Lock()
	defer db.mutex.Unlock()

	item := req.URL.Query().Get("item")
	delete(db.R, item)
	fmt.Fprint(w, "Success")
}

func (db database) price(w http.ResponseWriter, req *http.Request) {
	item := req.URL.Query().Get("item")
	if price, ok := db.R[item]; ok {
		fmt.Fprintf(w, "%s\n", price)
	} else {
		w.WriteHeader(http.StatusNotFound) // 404
		fmt.Fprintf(w, "no such item: %q\n", item)
	}
}

练习7.12:

修改/list的处理程序,改为输出HTML表格,而不是纯文本.可以考虑使用html/template包

这本书我已经数不清有多少个template包的练习了，老哥，这个模块是不是你写的！！！！！！
restful当道的年代,没多少机会拼html啦
即使拼html，这也相当于在python里面不用Jinja这种模板引擎，而跑去用python自带的string.Template一样

Go程序设计语言课后习题答案-第七章(接口)

第七章

练习7.1:

练习7.2:

练习7.3:

练习7.4:

练习7.5:

练习7.6:

练习7.7:

练习7.8:

练习7.9:

练习7.10:

练习7.11:

练习7.12:

ficapy

博客起航

IDM-Internet Download Manager

everything--文件搜索神器

everything进阶教程

Snagit-截图兼图片转换软件

xnview-图片查看

DeskPins-窗口置顶

傲梅分区助手--傻瓜化分区软件

excel数字递增批量打印

pip使用国内镜像