第5章 函数

函数可以让我们将一个语句序列打包成一个单元，然后可以从程序中其他地方多次调用，函数的机制可以让我们把一个大的工作分解成小任务。前面我们已经接触过函数，本章我们将讨论函数的更多特性

5.6 匿名函数

拥有函数名的函数只能在包级语法块中被声明，通过函数字面量，我们可绕过这一限制，在任何表达式中表示一个函数值

函数字面量的语法和函数声明相似，区别在于func关键字后没有函数名。函数值字面量是一种表达式，它的值被称为匿名函数

函数字面量允许我们在使用函数时，再定义它。通过这种技巧，我们可以改写之前对strings.Map的调用：

strings.Map(func(r rune) rune { return r + 1 }, "HAL-9000")

更为重要的是，通过这种方式定义的函数可以访问完整的词法环境（lexical environment），这意味着在函数中定义的内部函数可以引用该函数的变量，如下例所示：

func squares() func() int {var x intreturn func() int {x++return x * x}
}
func main() {f := squares()fmt.Println(f()) // "1"//每次调用都会改变xfmt.Println(f()) // "4"fmt.Println(f()) // "9"fmt.Println(f()) // "16"
}

squares的例子证明，函数值不仅仅是一串代码，还记录了状态

在squares中定义的匿名内部函数可以访问和更新squares中的局部变量，这意味着匿名函数中和squares中，存在和变量引用，这就是函数值属于引用类型和函数值不可比较的原因，Go使用闭包技术实现函数值，我们也把函数值叫闭包

通过这个例子，我们看到变量的生命周期不由它的作用域决定;squares返回后，变量仍然存在f中

我们再来讨论一个例子：给定一些计算机课程，每个课程都有一些前置课程，只有完成了前置课程才能进行正式课程的学习，我们的目标是选择出一组客户课程，这些课程必须按照顺序学习才能完成，每个课程的前置课程如下：

var prereqs = map[string][]string{"algorithms": {"data structures"},"calculus": {"linear algebra"},"compilers": {"data structures","formal languages","computer organization",},"data structures":       {"discrete math"},"databases":             {"data structures"},"discrete math":         {"intro to programming"},"formal languages":      {"discrete math"},"networks":              {"operating systems"},"operating systems":     {"data structures", "computer organization"},"programming languages": {"data structures", "computer organization"},
}

这类问题被称作拓扑排序，从概念上来说，前置条件构成了有向图，途中顶点表示课程，边表示课程间的依赖关系，并且图中应该无环，也就是说从某点出发的边，最终不会回到该点，下面的代码用深度优先搜索了整张图，获得了符合要求的课程序列

func topoSort (m map[string][]string) []string{var order []stringseen := make(map[string]bool)var visitAll func(items []string)visitAll = func(items []string){for _,item := range items{if !seen[item] {seen[item] =  truevisitAll(m[item])order = append(order, item)}}}var keys []stringfor key := range m {keys = append(keys,key)}sort.Strings(keys)visitAll(keys)return order
}

当匿名函数需要被递归调用时，必须先声明一个变量（上面我们声明的是visitAll）,再将匿名函数赋值给变量，如果不按此操作，那后续无法递归调用

visitAll :=func (item,[]string){//...visitAll(m[item])//...
}

在main函数种执行

func main() {for i,course := range topoSort(prereqs){fmt.Printf("%d:\t%s\n",i+1,course)}

输入如下结果，我们发现它是顺序输出的，我们再来研究一下这个问题，哈希表prepreqs的value是遍历顺序固定的切片，所以我们对key进行排序，保证每次运行topsort程序，遍历prepreqs都是相同的

1:	intro to programming
2:	discrete math
3:	data structures
4:	algorithms
5:	linear algebra
6:	calculus
7:	formal languages
8:	computer organization
9:	compilers
10:	databases
11:	operating systems
12:	networks
13:	programming languages

我们再来继续回顾一下之前的fundLinks例子，我们将代码移到links包下面，将函数重命名为Extract。我们用新的匿名函数来替换visit函数，该匿名函数负责将新链接添加到切片中。在Extract中，使用forEachNode来遍历HTML页面，由于Extract只需要在遍历节点前操作节点，所以forEachNode参数被传入nil

func Extract(url string) ([]string, error) {resp, err := http.Get(url)if err != nil {return nil, err}if resp.StatusCode != http.StatusOK {resp.Body.Close()return nil, fmt.Errorf("getting %s: %s", url, resp.Status)}doc, err := html.Parse(resp.Body)resp.Body.Close()if err != nil {return nil, fmt.Errorf("parsing %s as HTML: %v", url, err)}var links []stringvisitNode := func(n *html.Node) {if n.Type == html.ElementNode && n.Data == "a" {for _, a := range n.Attr {if a.Key != "href" {continue}link, err := resp.Request.URL.Parse(a.Val)if err != nil {continue // ignore bad URLs}links = append(links, link.String())}}}forEachNode(doc, visitNode, nil)return links, nil
}

上面的代码对之前的代码做了改进，现在links存储的不是href属性的原始值，而是通过resp.Request.URL解析后的值。解析后，这些链接以绝对路径方式存在，可以直接被http.Get访问

网页抓取地核心就是如何遍历图，在topSort例子中，已经展示了深度优先遍历，在网页抓取中我们将会展示如何利用广度优先遍历图

下面函数实现了广度优先算法，调用者需要输入两个参数，一个访问列表和一个函数f，待访问列表中每个元素被定义为string类型

广度优先算法会为每个元素调用一个f，每次f执行完毕后，会返回一组待访问元素，这些元素会被加入到待访问列表中,当待访问列表中地所有元素都被访问完以后breadthfirst函数会运行结束，为了避免同一个元素被访问两次，代码中维护了一个map

func breadthFirst(f func(item string) []string, worklist []string){seen := make(map[string]bool)for len(worklist) > 0 {items := worklistworklist = nilfor _,item := range items{if !seen[item] {seen[item] = trueworklist = append(worklist,f(item)...)}}}
}

就像之前所说，append地参数“f(item)…",会将f返回地元素一个个添加到worklist中

在我们的网页抓取器中，元素的类型是url,crawl函数会将URL输出，提取其中新链接，并将这些新链接返回，我们会将crawl作为参数传递给breadthFirst

func crawL(url string) []string{fmt.Println(url)list,err:= links.Extract(url)if err != nil{log.Print(err)}return list
}

为了使抓取器开始运行，我们用命令行输入参数作为初始的待访问url

func main() {breadthFirst(crawL,os.Args[1:])
}

我们从 https://golang.org开始，，如下是程序输出结果

https://golang.org/
https://golang.org/doc/
https://golang.org/pkg/
https://golang.org/project/
https://code.google.com/p/go-tour/
https://golang.org/doc/code.html
https://www.youtube.com/watch?v=XCsL89YtqCs
http://research.swtch.com/gotour

当所有发现的链接都已经被访问或者电脑内存耗尽时，程序运行你结束

5.6.1 警告：捕获迭代变量

我们来介绍一个Go词法作用域陷阱

我们思考一个这样的问题，传创建一个目录，然后将其删除，在下面中，我们用函数值来完成删除操作，下面的代码需要引入os包，为了使代码简单，我们忽略了异常处理

var rmdirs []func()
for _, d:= range os.TempDir()
dir := d
os.MkdirAll(dir,0775)
rmdirs = append(rmdirs, func() {os.RemoveAll(dir)
})
for _,rmdir := range rmdirs{rmdir()
}

为什么要在循环体中用循环遍历d赋值一个新的局部变量，而不是像下面代码一样直接使用dir（下面代码是错误的）

var rmdirs []func()
for _, dir := range tempDirs() {os.MkdirAll(dir, 0755)rmdirs = append(rmdirs, func() {os.RemoveAll(dir) // NOTE: incorrect!})
}

问题的原因在于循环变量的作用域，在上面的语句中，for循环使用了新的词法块，循环变量dir在这个词法块中被声明，在该循环中生成的所有函数值都共享相同的循环变量

需注意，函数值中记录的是循环变量的内存地址，而不是循环变量某一时刻的值，以dir为例，后续的迭代会不断更新dir的值，当删除操作执行时，for循环已完成，dir存储的值等于最后一次迭代的值，这意味着，每次对os.removeAll调用删除的都是相同的目录

通常，为了解决这个问题，我们会引入一个与循环变量名同名的局部变量，作为循环变量的副本，比如下面的例子，虽然奇怪，但是很有用

for _, dir := range os.TempDir(){dir:=dir//...
}

这个问题不仅存在基于range循环，在下面的例子中，对循环变量i的使用也存在同样问题：

var rmdirs []func()
dirs := os.TempDir()
for i:=0;i<len(dirs);i++{os.MkdirAll(dirs[i],0775)rmdirs = append(rmdir, func() {os.RemoveAll(dirs[i])//NOTE: incorrect!})
}

如果你使用Go语句，或者defer语句，会经常遇到此类问题，这不是go或者defer本身导致的，而是因为它们都会等循环结束再执行函数值