第五章

  • 函数声明
  • 递归
  • 多返回值
  • 错误
  • 函数变量
  • 匿名函数
  • 变长函数
  • 延迟函数调用
  • 宕机
  • 恢复

练习5.1

改变findlinks程序,使用递归调用visit(而不是循环)遍历n.FirstChild链表

  • 可怕的递归ヽ(*。>Д<)o゜可怕
  • 循环还挺好理解的,可是改成递归真。。。不好理解
  • 本题就修改一句就好了
1
return visit(visit(links, n.FirstChild), n.NextSibling)

练习5.2

写一个函数,用于统计HTML文档树内所有的元素个数,如p,div,span等

  • 将传入的slice修改为map,其他不变
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
package main
import (
"fmt"
"os"
"golang.org/x/net/html"
)
func main() {
doc, err := html.Parse(os.Stdin)
if err != nil {
fmt.Fprintf(os.Stderr, "findelems: %v\n", err)
os.Exit(1)
}
elements := map[string]int{}
visit(elements, doc)
for elem, count := range elements {
fmt.Printf("%s\t%d\n", elem, count)
}
}
func visit(e map[string]int, n *html.Node) {
if n.Type == html.ElementNode {
e[n.Data]++
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
visit(e, c)
}
}

练习5.3

写一个函数,用于输出HTML文档树种所有文本节点的内容.但不包括<script><style>元素,因为这些内容在web浏览器中是不可见的

  • 还是差不多,递归读取到每一个节点,选择性输出
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
package main
import (
"fmt"
"os"
"golang.org/x/net/html"
)
func main() {
doc, err := html.Parse(os.Stdin)
if err != nil {
fmt.Fprintf(os.Stderr, "findtexts: %v\n", err)
os.Exit(1)
}
visit(doc)
}
func visit(n *html.Node) {
if n != nil && n.Type == html.ElementNode {
if n.Data == "script" || n.Data == "style" {
return
}
}
if n.Type == html.TextNode {
fmt.Println(n.Data)
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
visit(c)
}
}

练习5.4:

扩展visit函数,使之能够获得到其他种类的链接地址,比如图片、脚本或样式表的链接

  • 用一个字典匹配所有的类型,先匹配n.Data,在遍历属性得到需要的地址

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    var filter = map[string]string{
    "a": "href",
    "img": "src",
    "script": "src",
    }
    func visit(links []string, n *html.Node) []string {
    for k, v := range filter {
    if n.Type == html.ElementNode && n.Data == k {
    for _, a := range n.Attr {
    if a.Key == v {
    links = append(links, a.Val)
    }
    }
    }
    }
    for c := n.FirstChild; c != nil; c = c.NextSibling {
    links = visit(links, c)
    }
    return links
    }

练习5.5:

实现函数countWordsAndImages

  • ElementNode、TextNode、ComentNode、DoctypeNode、ErrorNode
  • 判断为TextNode的时候统计字符个数,n.Data为img的时候图片数目累加
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func countWordsAndImages(n *html.Node) (words, images int) {
if n.Type == html.TextNode{
scanner := bufio.NewScanner(strings.NewReader(n.Data))
scanner.Split(bufio.ScanWords)
for scanner.Scan() {
words++
}
}
if n.Type == html.ElementNode && n.Data == "img" {
images++
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
ws, is := countWordsAndImages(c)
words += ws
images += is
}
return words, images
}

练习5.6:

修改gopl.io/ch3/surface中的函数corner,以使用命名的结果以及裸返回语句

  • 最简单的概念题了,返回参数规范化
  • return的时候忽略后面的语句,不过我想我写代码的时候可能不会选择忽略
1
2
3
4
5
6
7
8
9
10
func corner(i, j int) (sx, sy float64) {
x := xyrange * (float64(i)/cells - 0.5)
y := xyrange * (float64(j)/cells - 0.5)
z := f(x, y)
sx = width/2 + (x-y)*cos30*xyscale
sy = height/2 + (x+y)*sin30*xyscale - z*zscale
return
}

练习5.7:

开发startElement和endElement函数并应用到一个普通的HTML输出代码中.输出注释节点、文本节点和所有元素属性(<a href='...'>).当一个元素没有子节点时,使用简短的形式,比如<img/>而不是<img></img>.写一个测试程序保证输出可以正确解析

  • 抱歉,我感觉挺复杂

练习5.8:

修改forEachNode使得pre和post函数返回一个布尔型的结果来确定遍历是否继续下去.使用它写一个函数ElementByID,该函数使用下面的函数签名并且找到第一个符合id属性的HTML元素.函数在找到符合条件的元素时应该尽快停止遍历.func 使用它写一个函数ElementByID(doc html.Node, id string) html.Node

  • 终止递归,每次执行pre、post的时候选择判断返回值,如果为真表示找到直接进行return
  • 因为传递给forEachNode的是html.Node的指针,当return的时候即为找到的第一个id,如果遍历完了还没有,最终返回值为n.FirstChild会为nil
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func ElementByID(doc *html.Node, id string) *html.Node {
var elem *html.Node
forEachNode(doc,
func(n *html.Node) bool {
if n.Type == html.ElementNode {
for _, a := range n.Attr {
if a.Key == "id" && a.Val == id {
elem = n
return false
}
}
}
return true
},
nil)
return elem
}

练习5.9:

写一个函数expand(s string,f func(string)string)string,该函数替换参数s中每一个子字符串”$foo”为f(“foo”)的返回值

  • 感觉应该是类似于${foo}这样,否则$后面会有很长的字符串,不利于模板进行分割
1
2
3
4
5
6
7
8
package main
import "strings"
func Expand(s string, f func(string) string) string {
ret := strings.Replace(s, "$foo", f("foo"), 1024)
return ret
}

练习5.10:

重写topSort以使用map代替slice并去掉开头的排序.结果不是唯一的,验证这个结果是合法的拓扑排序

  • 跳过┑( ̄Д  ̄)┍

练习5.11:

现在有”线性代数”这门课程,它的先决课程是”微积分”.拓展topSort以函数输出结果

  • 跳过┑( ̄Д  ̄)┍

练习5.12:

5.5节(gopl.io/ch5/outline2)的startElement和endElement函数共享一个全局变量depth.把它们变为匿名函数以共享outline函数的一个局部变量

  • 跳过┑( ̄Д  ̄)┍

练习5.13:

修改crawl函数保存找到的页面,根据需要创建目录.不要保存不同域名下的页面.比如本来的页面来自golang.org,那么就把它们保存下来但是不要保存vimeo.com下的页面

  • 跳过┑( ̄Д  ̄)┍

练习5.14:

使用广度优先遍历搜索一个不同的拓扑结构.比如,你可以借鉴拓扑排序的例子里的课程依赖关系,计算机文件系统的分层结构,或者从当前城市的官网上下载公共汽车或者地铁的路线图.

  • 跳过┑( ̄Д  ̄)┍

练习5.15:

模仿sum写两个变长函数max和min.当不带任何参数调用这些函数的时候应该怎么应对?编写类似函数的变种,要求至少需要一个参数

  • 当缺少参数的时候直接panic
  • 比较的时候直接使用math模块的最大值最小值使用
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
package main
import "math"
func Max(in ...int) int {
if len(in) == 0 {
panic("At least one element")
}
ret := math.MinInt64
for _, v := range in {
if v > ret {
ret = v
}
}
return ret
}
func Min(in ...int) int {
if len(in) == 0 {
panic("At least one element")
}
ret := math.MaxInt64
for _, v := range in {
if v < ret {
ret = v
}
}
return ret
}

练习5.16:

写一个变长版本的strings.Join函数

  • 可以直接使用strings.Join返回
  • 选择使用bytes.Buffer模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
import (
"strings"
"bytes"
"fmt"
)
func Join(in ...string) string {
return strings.Join(in, "")
}
func Join2(in ...string) string {
var buf bytes.Buffer
for _, v := range in {
buf.Write([]byte(v))
}
return buf.String()
}
func main() {
fmt.Println(Join2("a", "b", "c"))
}

练习5.17:

写一个变长函数ElementsByTagname,已知一个HTML节点树和零个或多个名字,返回所有符合给出名字的元素

  • 衔接前面的题目,遍历判断一下即可
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import "golang.org/x/net/html"
func ElementsByTagName(doc *html.Node, name ...string) []*html.Node {
if len(name) == 0 {
return nil
}
var visit func(elems []*html.Node, n *html.Node) []*html.Node
visit = func(elems []*html.Node, n *html.Node) []*html.Node {
for _, tag := range name {
if n.Type == html.ElementNode && n.Data == tag {
elems = append(elems, n)
}
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
elems = visit(elems, c)
}
return elems
}
return visit(nil, doc)
}

练习5.18:

不改变原本的行为,重写fetch函数以使用defer语句关闭打开的可写的文件

  • 基本不变,直接将原有的写法放置到嵌套的defer函数内部,这样关闭失败的时候同样的逻辑会写入err
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func fetch(url string) (filename string, n int64, err error) {
resp, err := http.Get(url)
if err != nil {
return "", 0, err
}
defer resp.Body.Close()
local := path.Base(resp.Request.URL.Path)
if local == "/" {
local = "index.html"
}
f, err := os.Create(local)
if err != nil {
return "", 0, err
}
defer func() {
if closeErr := f.Close(); err == nil {
err = closeErr
}
}()
n, err = io.Copy(f, resp.Body)
return local, n, err
}

练习5.19:

使用panic和recover写一个函数,它没有return语句,但是能够返回一个非零的值

  • 利用defer语句的作用域和函数同级,在defer语句中执行recover再设置函数返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
func NoReturn() (r int) {
defer func() {
if p := recover(); p != nil {
r = 1
} else {
r = 2
}
}()
panic(1)
}
func main() {
fmt.Println(NoReturn())
}