【go语言圣经】练习答案--第一章
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)
}