函数是可以递归调用的，这意味着函数可以直接或者间接调用自身。对于一些问题而言，递归是一种非常有用的技术，例如处理递归的数据结构(树形结构)，在3.4节中，我们就通过遍历二叉树来实现简单的插入排序，在本节中，将再次使用这种技术来处理HTML文件。

本节后续的示例代码中使用了非标准包golang.org/x/net/html来解析HTML。golang.org/x/...目录下存放了一些由Go语言开发团队设计、维护的包，包含了网络编程、国际化文本处理、移动平台、图像处理、加密解密等，未将这些包加入到标准库的原因有两个：第一个是，有些包还处在开发中，第二个是，对于绝大多数Go语言开发者而言，这些包很少需要被使用。

示例中调用的golang.org/x/net/html的部分api源码如下所示，html.Parse函数读入字节序列并进行解析，然后返回HTML页面树中的节点，节点的类型是html.Node类型。HTML中拥有几种类型的节点：text、comments等等，这里我们只关注<name key='value'>这种形式的节点：

golang.org/x/net/html

package html

type Node struct {
    Type                    NodeType
    Data                    string
    Attr                    []Attribute
    FirstChild, NextSibling *Node
}

type NodeType int32

const (
    ErrorNode NodeType = iota
    TextNode
    DocumentNode
    ElementNode
    CommentNode
    DoctypeNode
)

type Attribute struct {
    Key, Val string
}

func Parse(r io.Reader) (*Node, error)

main函数会解析HTML标准输入，通过递归函数visit获得HTML元素中的链接，并打印出这些链接：

gopl.io/ch5/findlinks1

// Findlinks1 prints the links in an HTML document read from standard input.
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, "findlinks1: %v\n", err)
        os.Exit(1)
    }
    for _, link := range visit(nil, doc) {
        fmt.Println(link)
    }
}

visit函数会遍历HTML的节点树，从<a href='...'>类型的元素中获取链接，然后将这些链接存入slice中，并返回该slice:

// visit appends to links each link found in n and returns the result.
func visit(links []string, n *html.Node) []string {
    if n.Type == html.ElementNode && n.Data == "a" {
        for _, a := range n.Attr {
            if a.Key == "href" {
                links = append(links, a.Val)
            }
        }
    }
    for c := n.FirstChild; c != nil; c = c.NextSibling {
        links = visit(links, c)
    }
    return links
}

为了遍历节点n的所有孩子节点，每次遇到n的孩子节点时，visit递归的调用自身。这些孩子结点存放在FirstChild链表中。

让我们以Go的官方主页（golang.org）作为目标，运行findlinks。这里，将使用fetch的输出作为findlinks的输入。注意，下面的输出做了简化处理：

$ go build gopl.io/ch1/fetch
$ go build gopl.io/ch5/findlinks1
$ ./fetch https://golang.org | ./findlinks1
#
/doc/
/pkg/
/help/
/blog/
http://play.golang.org/
//tour.golang.org/
https://golang.org/dl/
//blog.golang.org/
/LICENSE
/doc/tos.html
http://www.google.com/intl/en/policies/privacy/

上面的返回中，存在了多种格式的链接，之后我们会介绍如何生成这些链接的绝对路径(根路径https://golang.org)。

在下面的函数outline中，我们将通过递归的方式遍历整个HTML节点树，并输出树的结构。在outline内部，每遇到一个HTML标签，都将其入栈，然后输出：

gopl.io/ch5/outline

func main() {
    doc, err := html.Parse(os.Stdin)
    if err != nil {
        fmt.Fprintf(os.Stderr, "outline: %v\n", err)
        os.Exit(1)
    }
    outline(nil, doc)
}
func outline(stack []string, n *html.Node) {
    if n.Type == html.ElementNode {
        stack = append(stack, n.Data) // push tag
        fmt.Println(stack)
    }
    for c := n.FirstChild; c != nil; c = c.NextSibling {
        outline(stack, c)
    }
}

有一点需要注意：虽然outline会把元素入栈，但是没有出栈操作。当outline递归调用自身时，被调用者将收到stack的拷贝，虽然被调用者可能会添加元素到该slice中，修改底层的数组，甚至重新分配一个新的数组，但是被调用者不会去修改调用者的传入的slice中的那些元素(也就是说,slice虽然会改变，但是slice中的元素只会增加，不会修改或者删除)，因此当函数返回时，调用者的特有的那部分stack还是和调用前相同(后面会增加被调用的stack)。

下面是 https://golang.org 页面的简要结构:

$ go build gopl.io/ch5/outline
$ ./fetch https://golang.org | ./outline
[html]
[html head]
[html head meta]
[html head title]
[html head link]
[html body]
[html body div]
[html body div]
[html body div div]
[html body div div form]
[html body div div form div]
[html body div div form div a]
...

正如上面的实验中展示的，大部分HTML页面只需要几层递归就能被处理完毕，但是仍然有部分页面需要深层次的递归才能完成。

很多编程语言使用固定大小的函数调用栈，常见的大小从64K到2MB不等，这样会限制递归的深度，因此用递归处理大量数据时，需要非常小心栈溢出问题以及安全性问题。与这些语言相反，Go使用的栈的大小是可变的，栈在初始化时会很小，然后按需增长(甚至可以增长到数G大小，取决于你的内存大小)，这样我们在使用递归时不需要考虑溢出和安全问题。

练习 5.1： 修改findlinks代码中遍历n.FirstChild链表的部分，将循环调用visit，改成递归调用。

练习 5.2： 编写函数，记录在HTML树中出现的同名元素的次数。

练习 5.3： 编写函数输出所有text结点的内容。注意不要访问<script>和<style>元素,因为这些元素对浏览者是不可见的。

练习 5.4： 扩展vist函数，使其能够处理其他类型的结点，如images、scripts和style sheets。