[日常] Go语言圣经-匿名函数习题

Go语言圣经-匿名函数
1.拥有函数名的函数只能在包级语法块中被声明，通过函数字面量（function literal），我们可绕过这一限制，在任何表达式中表示一个函数值
2.通过这种方式定义的函数可以访问完整的词法环境（lexical environment），这意味着在函数中定义的内部函数可以引用该函数的变量
3.函数值不仅仅是一串代码，还记录了状态，意味着匿名函数和父函数中，存在变量引用，函数值属于引用类型和函数值不可比较的原因。Go使用闭包（closures）技术实现函数值，Go程序员也把函数值叫做闭包
4.给定一些计算机课程，每个课程都有前置课程，只有完成了前置课程才可以开始当前课程的学习,这类问题被称作拓扑排序。从概念上说，前置条件可以构成有向图。

练习5.10：重写topoSort函数，用map代替切片并移除对key的排序代码。验证结果的正确性（结果不唯一）。

练习5.11：现在线性代数的老师把微积分设为了前置课程。完善topSort，使其能检测有向图中的环。

练习5.12： gopl.io/ch5/outline2（5.5节）的startElement和endElement共用了全局变量depth，将它们修改为匿名函数，使其共享outline中的局部变量。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

package main
 
import (
        "fmt"
        "golang.org/x/net/html"
        "net/http"
        "sort"
)
 
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 main() {
        for i, course := range topoSort(prereqs) {
                fmt.Printf("%d:\t%s\n", i+1, course)
        }   
        fmt.Println("------------------------")
        for k, v := range topoSort2(prereqs) {
                fmt.Printf("%d:\t%s\n", k, v)
        }   
        fmt.Println("------------------------")
        outline("http://mail.sina.net")
}
 
/*
练习5.10： 重写topoSort函数，用map代替切片并移除对key的排序代码。验证结果的正确性（结果不唯一）。
*/
func topoSort2(m map[string][]string) map[int]string {
        var order = make(map[int]string)
        index := 1
        seen := make(map[string]bool)
        var visitAll func(items []string)
        visitAll = func(items []string) {
                for _, item := range items {
                        if !seen[item] {
                                seen[item] = true
                                visitAll(m[item])
                                order[index] = item
                                index++
                        }
                }
        }
        var keys []string
        for key := range m {
                keys = append(keys, key)
        }
        visitAll(keys)
        return order
}
func topoSort(m map[string][]string) []string {
        var order []string
        seen := make(map[string]bool)
        var visitAll func(items []string)
        visitAll = func(items []string) {
                for _, item := range items {
                        if !seen[item] {
                                seen[item] = true
                                visitAll(m[item])
                                order = append(order, item)
                        }
                }
        }
        var keys []string
        for key := range m {
                keys = append(keys, key)
        }
        sort.Strings(keys)
        visitAll(keys)
        return order
}
 
/*
练习5.11： 现在线性代数的老师把微积分设为了前置课程。完善topSort，使其能检测有向图中的环。
等着去看数据结构再看这个题
*/
 
/*
练习5.12： gopl.io/ch5/outline2（5.5节）的startElement和endElement共用了全局变量depth，将它们修改为匿名函数，使其共享outline中的局部变量。
*/
func outline(url string) (string, error) {
        resp, err := http.Get(url)
        if err != nil {
                return "", err
        }
        doc, _ := html.Parse(resp.Body)
        //使用匿名函数实现
        var depth int
        var startElement func(n *html.Node)
        var endElement func(n *html.Node)
 
        startElement = func(n *html.Node) {
                if n.Type == html.ElementNode {
                        attr := ""
                        for _, a := range n.Attr {
                                attr += " " + a.Key + "=" + "\"" + a.Val + "\" "
                        }
                        fmt.Printf("%*s<%s%s", depth*2, "", n.Data, attr)
                        depth++
                }
                if n.Type == html.ElementNode && n.FirstChild == nil && n.Data != "script" {
                        fmt.Printf("/>\n")
                } else if n.Type == html.ElementNode {
                        fmt.Printf(">\n")
                }
 
                if n.Type == html.TextNode {
                        fmt.Printf("%*s %s\n", depth*2, "", n.Data)
                }
        }
        endElement = func(n *html.Node) {
                if n.Type == html.ElementNode && n.FirstChild == nil && n.Data != "script" {
                        depth--
                        fmt.Printf("\n")
                        return
                }
                if n.Type == html.ElementNode {
                        depth--
 
                        fmt.Printf("%*s</%s>\n", depth*2, "", n.Data)
                }
        }
        //1.使用函数值
        forEachNode(doc, startElement, endElement)
        resp.Body.Close()
        return "", nil
}
 
func forEachNode(n *html.Node, pre, post func(n *html.Node)) {
        //显式的调用一下
        if pre != nil {
                pre(n)
        }
 
        //fmt.Println(n.Data)
        for c := n.FirstChild; c != nil; c = c.NextSibling {
                forEachNode(c, pre, post)
        }
        if post != nil {
                post(n)
        }
}