Go语言之旅-go-tour练习答案

中文主页

https://tour.go-zh.org/

控制流

循环与函数

https://tour.go-zh.org/flowcontrol/8

简版，循环十次退出

package main
import (
     "fmt"
)

func Sqrt(x float64) float64 {
     z := float64(1)
     for i := 0; i <= 10; i++ {
          z = z - (z*z - x) / (2 * z)
     }
     return z
}

func main() {
     fmt.Println(Sqrt(2))
}

无限循环达到指定条件再退出

package main

import (
     "fmt"
     "math"
)

func Sqrt(x float64) float64 {
     z := float64(1)

     for {
          y := z - (z*z - x) / (2 * z)
          if math.Abs(y - z) < 1e-10 {
               return y
          }
          z = y;
     }
}

func main() {
     fmt.Println(Sqrt(2))
     fmt.Println(math.Sqrt(2))
}

更多类型

切片

https://tour.go-zh.org/moretypes/18

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
	myPic := make([][]uint8, dy)
	for i:=0; i<dy; i++{
		myPic[i] = make([]uint8, dx)
		for j:=0; j<dx; j++ {
			myPic[i][j] = uint8(i*j)
		}
	}
	return myPic
}

func main() {
	pic.Show(Pic)
}

图像：

• uint8(i*j)
  
• uint8((i+j)/2)
  
• uint8(i^j)
  
• uint8(i%(j+1))
  
• uint8(float64(i) * math.Log(float64(j)))
  

映射

https://tour.go-zh.org/moretypes/23

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	// 定义返回的计数器
	count := make(map[string]int)
	// 获取所有单词的数组
	allStrings := strings.Fields(s)
	for _, val := range allStrings {
		// 计数
		count[val]++
	}
	return count
}

func main() {
	wc.Test(WordCount)
}

斐波纳契闭包

https://tour.go-zh.org/moretypes/26

package main

import "fmt"

// 返回一个“返回int的函数”
func fibonacci() func() int {
	// 定义初始值
	sum1 := 0
	sum2 := 1
	return func() int {
		// 求和
		sum := sum1 + sum2
		// 更新
		sum1 = sum2
		sum2 = sum
		return sum
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

方法和接口

Stringer

https://tour.go-zh.org/methods/18

package main

import "fmt"

type IPAddr [4]byte

// TODO: 给 IPAddr 添加一个 "String() string" 方法
func (ip IPAddr) String() string {
	return fmt.Sprintf("%v.%v.%v.%v",ip[0],ip[1],ip[2],ip[3])
}

func main() {
	hosts := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for name, ip := range hosts {
		fmt.Printf("%v: %v\n", name, ip)
	}
}

错误

https://tour.go-zh.org/methods/20

package main

import (
	"fmt"
	"math"
)

type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
	return "cannot Sqrt negative number: " + fmt.Sprint(float64(e))
}
func Sqrt(x float64) (float64, error) {
	if x < 0 {
		return 0, ErrNegativeSqrt(x)
	}
	z := float64(1)
	for {
		y := z - (z*z-x)/(2*z)
		if math.Abs(y-z) < 1e-10 {
			return y, nil
		}
		z = y
	}
	return z, nil
}

func main() {
	fmt.Println(Sqrt(2))
	fmt.Println(Sqrt(-2))
}

Reader

https://tour.go-zh.org/methods/22

package main

import "golang.org/x/tour/reader"

type MyReader struct{}

// TODO: 给 MyReader 添加一个 Read([]byte) (int, error) 方法

func (r MyReader) Read(b []byte) (int, error) {
	b[0] = 'A'
	return 1, nil
}

func main() {
	reader.Validate(MyReader{})
}

rot13Reader

https://tour.go-zh.org/methods/23

package main

import (
	"io"
	"os"
	"strings"
)

type rot13Reader struct {
	r io.Reader
}

func r13Tran(in byte) (out byte) {
	switch {
	case in >= 'A' && in <= 'M' || in >= 'a' && in <= 'm':
		out = in + 13
	case in >= 'N' && in <= 'Z' || in >= 'n' && in <= 'z':
		out = in - 13
	default:
		out = in
	}
	return
}

func (r13 rot13Reader) Read(b []byte) (int, error) {
	n, e := r13.r.Read(b)
	for i := 0; i < n; i++ {
		b[i] = r13Tran(b[i])
	}
	return n, e
}
func main() {
	s := strings.NewReader("Lbh penpxrq gur pbqr!")
	r := rot13Reader{s}
	io.Copy(os.Stdout, &r)
}

图像

https://tour.go-zh.org/methods/25

package main

import (
	"image"
	"image/color"

	"golang.org/x/tour/pic"
)

type Image struct {
	W int
	H int
}

func (i Image) Bounds() image.Rectangle {
	return image.Rect(0, 0, i.W, i.H)
}

func (i Image) ColorModel() color.Model {
	return color.RGBAModel
}

func (i Image) At(x, y int) color.Color {
	return color.RGBA{uint8(x), uint8(y), 255, 255}
}

func main() {
	m := Image{100, 100}
	pic.ShowImage(m)
}

并发

等价二叉查找树

https://tour.go-zh.org/concurrency/8

package main

import "fmt"
import "golang.org/x/tour/tree"

// Walk 步进 tree t 将所有的值从 tree 发送到 channel ch。
func Walk(t *tree.Tree, ch chan int) {
	if t == nil {
		return
	}
	Walk(t.Left, ch)
	ch <- t.Value
	Walk(t.Right, ch)
}

// Same 检测树 t1 和 t2 是否含有相同的值。
func Same(t1, t2 *tree.Tree) bool {
	ch1 := make(chan int)
	ch2 := make(chan int)
	go Walk(t1, ch1)
	go Walk(t2, ch2)
	for i := 0; i < 10; i++ {
		x, y := <-ch1, <-ch2
		fmt.Println(x, y)
		if x != y {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println("测试 Walk 函数。")
	ch := make(chan int)
	t := tree.New(1)
	go Walk(t, ch)
	for i := 0; i < 10; i++ {
		a := <-ch
		fmt.Println(a)
	}
	fmt.Println("测试 Same 函数。")
	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(5)))
}

Web爬虫

https://tour.go-zh.org/concurrency/10

package main

import (
	"fmt"
	"sync"
)

type Cache struct {
	cache map[string]bool
	mutex sync.Mutex
}

var cache Cache = Cache{
	cache: make(map[string]bool),
}

func (c *Cache) add(url string) {
	c.mutex.Lock()
	c.cache[url] = true
	c.mutex.Unlock()
}

func (c *Cache) has(url string) bool {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	_, ok := c.cache[url]
	if !ok {
		c.cache[url] = true
	}
	return ok
}

type Fetcher interface {
	// Fetch 返回 URL 的 body 内容，并且将在这个页面上找到的 URL 放到一个 slice 中。
	Fetch(url string) (body string, urls []string, err error)
}

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher, wg *sync.WaitGroup) {
	defer wg.Done()
	// TODO: 并行的抓取 URL。
	// TODO: 不重复抓取页面。
	// 下面并没有实现上面两种情况：
	if depth <= 0 {
		return
	}
	if cache.has(url) {
		return
	}
	body, urls, err := fetcher.Fetch(url)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("found: %s %q\n", url, body)
	for _, u := range urls {
		wg.Add(1)
		go Crawl(u, depth-1, fetcher, wg)
	}
	return
}

func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go Crawl("https://golang.org/", 6, fetcher, &wg)
	wg.Wait()
}

// fakeFetcher 是返回若干结果的 Fetcher。
type fakeFetcher map[string]*fakeResult

type fakeResult struct {
	body string
	urls []string
}

func (f fakeFetcher) Fetch(url string) (string, []string, error) {
	if res, ok := f[url]; ok {
		return res.body, res.urls, nil
	}
	return "", nil, fmt.Errorf("not found: %s", url)
}

// fetcher 是填充后的 fakeFetcher。
var fetcher = fakeFetcher{
	"https://golang.org/": &fakeResult{
		"The Go Programming Language",
		[]string{
			"https://golang.org/pkg/",
			"https://golang.org/cmd/",
		},
	},
	"https://golang.org/pkg/": &fakeResult{
		"Packages",
		[]string{
			"https://golang.org/",
			"https://golang.org/cmd/",
			"https://golang.org/pkg/fmt/",
			"https://golang.org/pkg/os/",
		},
	},
	"https://golang.org/pkg/fmt/": &fakeResult{
		"Package fmt",
		[]string{
			"https://golang.org/",
			"https://golang.org/pkg/",
		},
	},
	"https://golang.org/pkg/os/": &fakeResult{
		"Package os",
		[]string{
			"https://golang.org/",
			"https://golang.org/pkg/",
		},
	},
}