《go语言圣经》习题答案-第5章

目录

5.11

5.13

5.14

5.15

5.16

5.17

5.19

---

习题答案，个人理解，欢迎交流指正

5.11

package main

import (
	"fmt"
	"sort"
)

var dict = map[string][]string{
	"algorithms":     {"data structures"},
	"calculus":       {"linear algebra"},
	"linear algebra": {"calculus"},
	"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() {
	list, ok := toposort(dict)
	if !ok {
		fmt.Println("存在环")
		return
	}
	for i, s := range list {
		fmt.Printf("%d\t%s\n", i+1, s)
	}
}

func toposort(dict map[string][]string) ([]string, bool) {
	var list []string
	seen := make(map[string]bool)
	wait := make(map[string]bool)

	var visitAll func(items []string) bool
	visitAll = func(items []string) bool {
		for _, item := range items {
			if !seen[item] {
				seen[item] = true
				wait[item] = true
				if !visitAll(dict[item]) {
					return false
				}
				list = append(list, item)
				wait[item] = false

			} else if wait[item] {
				return false
			}
		}
		return true
	}

	var keys []string
	for key := range dict {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	if !visitAll(keys) {
		return nil, false
	}
	return list, true
}

5.13

package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"

	neturl "net/url"
	"os"

	"golang.org/x/net/html"
	"gopl.io/util"
)

func Extract(url string, hosts map[string]bool) ([]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)
	}
	content, _ := ioutil.ReadAll(resp.Body)
	contentstr := string(content)
	doc, err := html.Parse(strings.NewReader(contentstr))
	resp.Body.Close()
	if err != nil {
		return nil, fmt.Errorf("parsing %s as HTML: %v", url, err)
	}
	var links []string
	visitNode := func(n *html.Node) {
		u, err := neturl.Parse(url)
		if err != nil {
			fmt.Printf("解析路径%s失败 %s\n", url, err)
		}
		dir := u.Host
		if n.Type == html.ElementNode && n.Data == "title" && hosts[dir] {
			name := n.FirstChild.Data
			mkErr := os.Mkdir(dir, os.ModePerm)
			if mkErr != nil && os.IsNotExist(mkErr) {
				fmt.Printf("创建文件夹[%s]失败 %s\n", dir, mkErr)
			}
			fn := dir + "/" + name + ".html"
			file, err := os.OpenFile(fn, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
			if err != nil {
				fmt.Printf("创建文件[%s]失败 %s\n", fn, err)
			} else {
				fmt.Printf("保存文件 %s\n", fn)
				file.WriteString(contentstr)
				file.Close()
			}
		}
		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
				}
				links = append(links, link.String())
			}
		}
	}
	util.ForEachNode(doc, visitNode, nil)
	return links, nil
}

package main

import (
	"fmt"
	"log"
	"net/url"
	"os"
	"strings"
)

func main() {
	urls := os.Args[1:]
	seen := map[string]bool{}
	toVisit := []string{}
	toVisit = append(toVisit, urls...)

	hosts := map[string]bool{}
	for _, u := range urls {
		uu, err := url.Parse(u)
		if err == nil {
			hosts[uu.Host] = true
		}
	}

	for len(toVisit) != 0 {
		links := toVisit
		toVisit = nil
		for _, link := range links {
			if strings.HasSuffix(link, "/") {
				link = link[:len(link)-1]
			}
			if !seen[link] {
				fmt.Println(link)
				seen[link] = true
				l, err := Extract(link, hosts)
				if err != nil {
					log.Print(err)
				}
				toVisit = append(toVisit, l...)
			}
		}
	}
}

5.14

package main

import (
	"fmt"
	"io/ioutil"
	"os"
)

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

func crawlCourse() {
	var dict = map[string][]string{
		"algorithms":     {"data structures"},
		"calculus":       {"linear algebra"},
		"linear algebra": {"calculus"},
		"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"},
	}
	f := func(s string) []string {
		fmt.Println(s)
		return dict[s]
	}
	items := []string{}
	for k, _ := range dict {
		items = append(items, k)
	}
	Bfs(f, items)
}

func crawlFile() {
	root := []string{"gopl.io"}
	f := func(path string) []string {
		s, _ := os.Stat(path)
		if !s.IsDir() {
			fmt.Println(path)
			return nil
		}
		rd, err := ioutil.ReadDir(path)
		if err != nil {
			fmt.Printf("read dir[%s] faild %s\n", path, err)
			return nil
		}
		files := []string{}
		for _, fi := range rd {
			files = append(files, path+"/"+fi.Name())
		}
		return files
	}
	Bfs(f, root)
}

func main() {
	crawlCourse()
	crawlFile()
}

5.15

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println(max())
	fmt.Println(max(4))
	fmt.Println(max(8, 4, 9))
}

func max(vals ...int) int {
	if len(vals) == 0 {
		return math.MaxInt
	}
	m := math.MinInt
	for _, n := range vals {
		if n > m {
			m = n
		}
	}
	return m
}

package main

import (
	"fmt"
)

func main() {
	fmt.Println(max(4))
	fmt.Println(max(8, 4, 9))
}

func max(val int, vals ...int) int {
	for _, n := range vals {
		if n > val {
			val = n
		}
	}
	return val
}

5.16

package main

import (
	"bytes"
	"fmt"
)

func main() {
	fmt.Println(join(",", []string{"wewei"}...))
	fmt.Println(join(",", []string{}...))
	fmt.Println(join("", []string{"weiwei", "zheng"}...))
}

func join(sep string, strs ...string) string {
	var buf bytes.Buffer
	s := ""
	for _, str := range strs {
		buf.WriteString(s)
		buf.WriteString(str)
		s = sep
	}
	return buf.String()
}

5.17

package main

import (
	"fmt"
	"net/http"
	"os"

	"golang.org/x/net/html"
)

func main() {
	resp, err := http.Get("https://www.hao123.com")
	if err != nil {
		fmt.Fprintf(os.Stderr, "echo: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	doc, err := html.Parse(resp.Body)
	if err != nil {
		fmt.Fprintf(os.Stderr, "echo: %v\n", err)
		os.Exit(1)
	}

	nodes1 := ElementsByTagName(doc, "div")
	nodes2 := ElementsByTagName(doc, "a")
	nodes3 := ElementsByTagName(doc, "div", "a")
	fmt.Printf("%d, %d, %d\n", len(nodes1), len(nodes2), len(nodes3))
}

func ElementsByTagName(doc *html.Node, names ...string) []*html.Node {
	tags := make(map[string]bool)
	for _, n := range names {
		tags[n] = true
	}
	var list []*html.Node
	var forEachNode func(doc *html.Node)
	forEachNode = func(doc *html.Node) {
		if doc.Type == html.ElementNode && tags[doc.Data] {
			list = append(list, doc)
		}
		for c := doc.FirstChild; c != nil; c = c.NextSibling {
			forEachNode(c)
		}
	}

	forEachNode(doc)
	return list

}

5.19

package main

import (
	"fmt"
)

func main() {
	fmt.Println(f())
}

func f() (code int) {
	defer func() {
		if p := recover(); p != nil {
			code = 1
		}
	}()
	panic("")
}