【go语言圣经】练习答案--第一章

最新推荐文章于 2024-01-18 14:37:01 发布

置顶金戋

最新推荐文章于 2024-01-18 14:37:01 发布

阅读量4.6k

点赞数 2

分类专栏： GO Golang Go圣经

本文链接：https://blog.csdn.net/q1576962841/article/details/85162346

版权

GO 同时被 3 个专栏收录

5 篇文章 4 订阅

订阅专栏

Golang

3 篇文章 0 订阅

订阅专栏

Go圣经

3 篇文章 0 订阅

订阅专栏

Golang圣经课后题，一部分是自己写的，一部分是转载的--定时更新

练习 1.1：修改 echo 程序，使其能够打印 os.Args[0] ，即被执行命令本身的名字

package main

import (
	"fmt"
	"os"
)

func main() {
	var s, sep string
	for i := 0; i < len(os.Args); i++ {
		s += sep + os.Args[i]
		sep = " "
	}
	fmt.Println(s)
}

练习 1.2：修改 echo 程序，使其打印每个参数的索引和值，每个一行

package main

import (
	"fmt"
	"os"
)

func main() {
	for k, arg := range os.Args[0:] {
		fmt.Println(k, arg)
	}
}

练习 1.3：做实验测量潜在低效的版本和使用了 strings.Join 的版本的运行时间差异。（1.6节讲解了部分 time 包，11.4节展示了如何写标准测试程序，以得到系统性的性能评测。）

package main

import (
	"strings"
	"testing"
)

func BenchmarkString2Join(b *testing.B) {
	for i := 0; i < b.N; i++ {
		input := []string{"Welcome", "To", "China"}
		result := strings.Join(input, " ")
		if result != "Welcome To China" {
			b.Error("Unexcepted result:" + result)
		}
	}
}

func BenchmarkString2Plus(b *testing.B) {
	for i := 0; i < b.N; i++ {
		input := []string{"Welcome", "To", "China"}
		var s, sep string
		for j := 0; j < len(input); j++ {
			s += sep + input[i]
			sep = " "
		}
		if s != "Welcome To China" {
			b.Error("Unexcepted result:" + s)
		}
	}
}

练习 1.4：修改 dup2 ，出现重复的行时打印文件名称。

package main

import (
	"bufio"
	"fmt"
	"os"
)

type LnFile struct {
	Count     int
	Filenames []string
}

func main() {
	counts := make(map[string]*LnFile)
	files := os.Args[1:]
	if len(files) == 0 {
		countLines(os.Stdin, counts)
	} else {
		for _, arg := range files {
			f, err := os.Open(arg)
			if err != nil {
				fmt.Fprintf(os.Stderr, "dup2:%v\n", err)
			}
			countLines(f, counts)
			f.Close()
		}
	}
	for line, n := range counts {
		if n.Count > 1 {
			fmt.Printf("%d %v\n%s\n", n.Count, n.Filenames, line)
		}
	}
}

func countLines(f *os.File, counts map[string]*LnFile) {
	input := bufio.NewScanner(f)
	for input.Scan() {
		key := input.Text()
		_, ok := counts[key]
		if ok {
			counts[key].Count++
			counts[key].Filenames = append(counts[key].Filenames, f.Name())
		} else {
			counts[key] = new(LnFile)
			counts[key].Count = 1
			counts[key].Filenames = append(counts[key].Filenames, f.Name())
		}
	}
}

练习 1.5：修改前面的Lissajous程序里的调色板，由黑色改为绿色。我们可以用 color.RGBA{0xRR, 0xGG, 0xBB, 0xff} 来得到 #RRGGBB 这个色值，三个十六进制的字符串分别代表红、绿、蓝像素。

package main

import (
	"image"
	"image/color"
	"image/gif"
	"io"
	"math"
	"math/rand"
	"os"
)

var palette = []color.Color{color.RGBA{ 0, 0, 0, 0xFF}, color.RGBA{ 0, 0xFF, 0, 0xFF}}

func main() {
	lissajous(os.Stdout)
}

func lissajous(out io.Writer) {
	const (
		cycles  = 5    
		res     = 0.001 
		size    = 100   
		nframes = 64    
		delay   = 8     
	)
	freq := rand.Float64() * 3.0 
	anim := gif.GIF{LoopCount: nframes}
	phase := 0.0                 
	for i := 0; i < nframes; i++ {
		rect := image.Rect(0, 0, 2*size+1, 2*size+1)
		img := image.NewPaletted(rect, palette)
		for t := 0.0; t < cycles*2*math.Pi; t += res {
			x := math.Sin(t)
			y := math.Sin(t*freq + phase)
			img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), 1)
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim) 
}

练习 1.6：修改Lissajous程序，修改其调色板来生成更丰富的颜色，然后修改SetColorIndex的第三个参数，看看显示结果

package main

import (
	"image"
	"image/color"
	"image/gif"
	"io"
	"math"
	"math/rand"
	"os"
	"time"
)

const nColors = 10

func main() {
	seed := time.Now()
	rand.Seed( seed.Unix() )

	var palette []color.Color

	for i := 0; i < nColors; i++ {
		r := uint8(rand.Uint32() % 256)
		g := uint8(rand.Uint32() % 256)
		b := uint8(rand.Uint32() % 256)
		palette = append( palette, color.RGBA{ r, g, b, 0xFF} )
	}

	lissajous(os.Stdout, palette)
}

func lissajous(out io.Writer, palette []color.Color) {
	const (
		cycles  = 5
		res     = 0.001
		size    = 100
		nframes = 64
		delay   = 8
	)
	freq := rand.Float64() * 3.0
	anim := gif.GIF{LoopCount: nframes}
	phase := 0.0
	for i := 0; i < nframes; i++ {
		rect   := image.Rect(0, 0, 2*size+1, 2*size+1)
		img    := image.NewPaletted(rect, palette)
		ncolor := uint8(i % len(palette))
		for t := 0.0; t < cycles*2*math.Pi; t += res {
			x := math.Sin(t)
			y := math.Sin(t*freq + phase)
			img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), ncolor )
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim)
}

练习 1.7：函数调用io.Copy(dst, src)会从src中读取内容，并将读到的结果写入到dst中，使用这个函数替代掉例子中的ioutil.ReadAll来拷贝响应结构体到os.Stdout，避免申请一个缓冲区（例子中的b）来存储。记得处理io.Copy返回结果中的错误

package main

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

func main() {
	for _, url := range os.Args[1:] {
		resp, err := http.Get(url)
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1)
		}
		b, err := io.Copy(os.Stdout, resp.Body)
		resp.Body.Close()
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("%s", b)

	}
}

练习 1.8：修改fetch这个范例，如果输入的url参数没有 http:// 前缀的话，为这个url加上该前缀。你可能会用到strings.HasPrefix这个函数。

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	for _, url := range os.Args[1:] {
		if !strings.HasPrefix(url, "http://") {
			//url = "http://" + url
			url = strings.Join([]string{"http://", url}, "")
		}
		resp, err := http.Get(url)
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1)
		}
		b, err := io.Copy(os.Stdout, resp.Body)
		resp.Body.Close()
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("%s", b)
	}
}

练习 1.9：修改fetch打印出HTTP协议的状态码，可以从resp.Status变量得到该状态码。

package main

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

func main() {
	for _, url := range os.Args[1:] {
		resp, err := http.Get(url)
		if err != nil {
			fmt.Fprintf(os.Stdin, "fetch: %v\n", err)
			os.Exit(1)
		}
		b := resp.Status
		fmt.Printf("%s", b)
	}
}

1.10：找一个数据量比较大的网站，用本小节中的程序调研网站的缓存策略，对每个URL执行两遍请求，查看两次时间是否有较大的差别，并且每次获取到的响应内容是否一致，修改本节中的程序，将响应结果输出，以便于进行对比。

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, url := range os.Args[1:] {
		go fetch(url, ch)
		go fetch(url, ch)
	}

	for range os.Args[1:] {
		fmt.Println(<-ch)
		fmt.Println(<-ch)
	}

	fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	nbytes, err := io.Copy(ioutil.Discard, resp.Body)

	if err != nil {
		ch <- fmt.Sprint("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("%.2fs  %7d  %s", secs, nbytes, url)
}

练习 1.12：修改Lissajour服务，从URL读取变量，比如你可以访问 http://localhost:8000/?cycles=20 这个URL，这样访问可以将程序里的cycles默认的5修改为20。字符串转换为数字可以调用strconv.Atoi函数。你可以在godoc里查看strconv.Atoi的详细说明。

package main

import (
  "image"
  "image/color"
  "image/gif"
  "io"
  "math"
  "math/rand"
  "strconv"
)

import (
  "log"
  "net/http"
  "time"
)

var palette = []color.Color{color.White, color.Black}

const (
  whiteIndex = 0
  blackIndex = 1
)

type lconfig struct {
  cycles float64
  res    float64
  freq   float64
  size   int
  frames int
  delay  int
}

func main() {
  rand.Seed(time.Now().UnixNano())
  lconf := lconfig {
    cycles  : 5,
    res     : 0.001,
    freq    : rand.Float64() * 3.0,
    size    : 100,
    frames  : 64,
    delay   : 8,
  }

  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    confs := r.URL.Query()
    for i, c := range confs {
      switch i {
      case "cycles" : lconf.cycles, _ = strconv.ParseFloat( c[0], 64 )
      case "freq"   : lconf.freq  , _ = strconv.ParseFloat( c[0], 64 )
      case "res"    : lconf.res   , _ = strconv.ParseFloat( c[0], 64 )
      case "size"   : lconf.size  , _ = strconv.Atoi( c[0] )
      case "frames" : lconf.frames, _ = strconv.Atoi( c[0] )
      case "delay"  : lconf.delay , _ = strconv.Atoi( c[0] )
      }
    }

    lissajous(w, lconf)
  })

  log.Fatal(http.ListenAndServe("localhost:8000", nil))
  return
}

func lissajous(out io.Writer, set lconfig) {
  anim  := gif.GIF{LoopCount: set.frames}
  phase := 0.0 // phase difference
  for i := 0; i < set.frames; i++ {
    rect := image.Rect(0, 0, 2*set.size+1, 2*set.size+1)
    img := image.NewPaletted(rect, palette)
    for t := 0.0; t < set.cycles*2*math.Pi; t += set.res {
      x := math.Sin(t)
      y := math.Sin(t*set.freq + phase)
      img.SetColorIndex(set.size+int(x*float64(set.size)+0.5), set.size+int(y*float64(set.size)+0.5), blackIndex)
    }
    phase += 0.1
    anim.Delay = append(anim.Delay, set.delay)
    anim.Image = append(anim.Image, img)
  }
  gif.EncodeAll(out, &anim)
}

查看目录

金戋

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
【go语言圣经】练习答案--第一章

Golang圣经课后题，一部分是自己写的，一部分是转载的--定时更新练习 1.1：修改 echo 程序，使其能够打印 os.Args[0] ，即被执行命令本身的名字package mainimport ( "fmt" "os")func main() { var s, sep string for i := 0; i < len(os.Args); i++ {...
复制链接

扫一扫