Go语言圣经-匿名函数习题详解编程语言

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