ch1/ch1-07

[giscus[bot]]

ch1/ch1-07

中文版

https://gopl-zh.github.io/ch1/ch1-07.html

[tsy529]

server2：
为什么当访问/count的时候，访问/中的count++被执行了，但没有执行fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)呢？

[KairuiLiu]

浏览器在访问网站时会默认请求 /favicon.ico 获取网站图标, 这个请求命中了 / 路径的处理函数, 可以尝试将 / 路径换成 /demo, 将/count换成/demo/count 即可解决这个问题

[lanmao0204]

/count 是/ 适配符的字符 在访问时先适配/ 再适配/count 所以在访问/count的时候会执行/的handler 也就是count会++

[lanmao0204]

子符 错别字

[juliofeng]

浏览器会有额外的访问我用的Chrome每次会+3，用命令行正常的

[kkyyz]

浏览器在访问网站时会默认请求 /favicon.ico 获取网站图标，所以在访问 /count 时访问了两个网站，分别匹配不同的函数规则。但因为 /favicon.ico 是隐式请求，输出页面被占用，所以无法显示 URL.Path

[parwjs]

为什么使用/访问服务器，count会加3呢？

[KairuiLiu]

浏览器在访问网站时会默认请求 /favicon.ico 获取网站图标, 这个请求命中了 / 路径的处理函数, 可以尝试将 / 路径换成 /demo, 将/count换成/demo/count 即可解决这个问题

[haiki]

按照文中的做饭，输入 /hello/world, 或者 /world/hello 都会echo出这个path，同时count + 3；
按照你这个做法，将 / 路径换成 /demo，再次访问 /hello/demo 是访问不到的，只能访问 /demo ，此时访问count能得到1。
你这个解法俩问题：

1. 只能访问/demo 对吗？
2. 每次访问 /demo/count 应该也要算一次计数？目前看没有计数

[haiki]

看了下go中http路由匹配规则，注册路径要写成 /demo/，以及 /demo/count/ 才能和文中的逻辑对上，即最后要加个 /。

[kkyyz]

可以抓包查看。由于网站默认请求 /favicon.ico，所以在以/count、/hello、/count访问时，实际请求报文顺序大致为 /count、/favicon.ico、/hello、/favicon.ico、/count、/favicon.ico，所以count+3。

[Rexoen]

Exercise 1.12

package main

import (
	"fmt"
	"image"
	"image/color"
	"image/gif"
	"io"
	"log"
	"math"
	"math/rand"
	"net/http"
	"strconv"
	"sync"
)

var palette = []color.Color{color.White, color.Black, color.RGBA{0x00, 0xff, 0x00, 0x4a}, color.RGBA{0xff, 0x00, 0x00, 0xff}}

const (
	whiteIndex = 0
	blackIndex = 1
	greenIndex = 2
	redIndex   = 3
)

func lissajous(cycle int, out io.Writer) {
	const (
		// cycles  = 5
		res     = 0.001
		size    = 100
		nframes = 256
		delay   = 8
	)
	if cycle == 0 {
		cycle = 5
	}
	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 < float64(cycle)*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), redIndex)
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim)
}

var mu sync.Mutex
var count int

func main() {
	http.HandleFunc("/", handler)
	http.HandleFunc("/count", counter)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	count++
	if err := r.ParseForm(); err != nil {
		log.Print(err)
	}
	var cycle string
	for k, v := range r.Form {
		if k == "cycle" {
			cycle = v[0]
		}
	}

	cycle_int, err := strconv.Atoi(cycle)
	if err != nil {
		cycle_int = 5
		// fmt.Fprintf(w, "%v\na valid decimal cycle argument is required, not the '%v'", err, cycle)
	}
	lissajous(cycle_int, w)
	mu.Unlock()
}

func counter(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	fmt.Fprintf(w, "Count %d\n", count)
	mu.Unlock()
}

[chenchenchenmo]

// lissajous产生随机利萨茹图形的GIF动画
package main

import (
"image"
"image/color"
"image/gif"
"io"
"log"
"math"
"math/rand"
"net/http"
"os"
"strconv"
"time"
)

var palette = []color.Color{color.White, color.Black, color.RGBA{0, 128, 0, 255}}

const (
whiteIndex = 0 //画板中的第一种颜色 --这里是画板底色
blackIndex = 1 // 画板中的下一种颜色
blueIndex = 2
)

func main() {
rand.Seed(time.Now().UTC().UnixNano())
if len(os.Args) > 1 && os.Args[1] == "web" {
//http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
// lissajous(w)
//})
handler := func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
log.Print(err)
}
cycles, err := strconv.Atoi(r.Form.Get("cycles")) // 字符串转int
if err != nil {
log.Print(err)
}
lissajous(w, float64(cycles))
}
http.HandleFunc("/get_gif", handler)
log.Fatal(http.ListenAndServe("localhost:8080", nil))
return
}
lissajous(os.Stdout, 5)
}

func lissajous(out io.Writer, cycles float64) {
const (
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, 2size+1, 2size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles2math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(tfreq + phase)
img.SetColorIndex(size+int(xsize+0.5), size+int(y*size+0.5), blueIndex) //这里最后一个参数是palette的下标吧
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}

[chenchenchenmo]

// lissajous产生随机利萨茹图形的GIF动画
package main

import (
	"image"
	"image/color"
	"image/gif"
	"io"
	"log"
	"math"
	"math/rand"
	"net/http"
	"os"
	"strconv"
	"time"
)

var palette = []color.Color{color.White, color.Black, color.RGBA{0, 128, 0, 255}}

const (
	whiteIndex = 0 //画板中的第一种颜色  --这里是画板底色
	blackIndex = 1 // 画板中的下一种颜色
	blueIndex  = 2
)

func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	if len(os.Args) > 1 && os.Args[1] == "web" {
		//http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		//	lissajous(w)
		//})
		handler := func(w http.ResponseWriter, r *http.Request) {
			if err := r.ParseForm(); err != nil {
				log.Print(err)
			}
			cycles, err := strconv.Atoi(r.Form.Get("cycles")) // 字符串转int
			if err != nil {
				log.Print(err)
			}
			lissajous(w, float64(cycles))
		}
		http.HandleFunc("/get_gif", handler)
		log.Fatal(http.ListenAndServe("localhost:8080", nil))
		return
	}
	lissajous(os.Stdout, 5)
}

func lissajous(out io.Writer, cycles float64) {
	const (
		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), blueIndex) //这里最后一个参数是palette的下标吧
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim)
}

[lyb88999]

`go
package main

import (
"fmt"
"image"
"image/color"
"image/gif"
"io"
"log"
"math"
"math/rand"
"net/http"
"strconv"
)

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

const (
whiteIndex = 0
blackIndex = 1
)

func lissajous(out io.Writer, cycles float64) {
const (
// cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)

freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
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),
			blackIndex)
	}
	phase += 0.1
	anim.Delay = append(anim.Delay, delay)
	anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors

}

func main() {
http.HandleFunc("/", handler3)
handler4 := func(w http.ResponseWriter, r *http.Request) {
cycleString := r.FormValue("cycles")
cycles, err := strconv.ParseFloat(cycleString, 64)
if err != nil {
http.Error(w, "Invalid cycles value", http.StatusBadRequest)
}
lissajous(w, cycles)
}
http.HandleFunc("/pic", handler4)
log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

func handler3(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
for k, v := range r.Header {
fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
}
fmt.Fprintf(w, "Host=%q\n", r.Host)
fmt.Fprintf(w, "RemoteAddr=%q\n", r.RemoteAddr)
if err := r.ParseForm(); err != nil {
log.Print(err)
}
for k, v := range r.Form {
fmt.Fprintf(w, "Form[%q]=%q\n", k, v)
}
}
`

[wanglei409]

到此乙流

[Fi-tang]

package main

import (
	"image/color"
	"image"
	"image/gif"
	"io"
	"math"
	"math/rand"
	"time"
	"net/http"
	"log"
	"strconv"
	"fmt"
)

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

const (
	blackIndex = 0
	whiteIndex = 1
	greenIndex = 2
	redIndex = 3
	blueIndex = 4
)

var cycles = 5.0

func lissajour(w io.Writer){
	const (
		size = 100
		delay = 8
		res = 0.001
		nframe = 64
	)
	rand.Seed(time.Now().UTC().UnixNano())

	freq := rand.Float64() * 3.0
	phase := 0.0
	anim := gif.GIF{LoopCount: nframe}

	for i := 0; i < nframe; i++ {
		rect := image.Rect(0,0,2 * size + 1, 2 * size + 1)
		img := image.NewPaletted(rect, palette)

		for t := 0.0; t < 2 * math.Pi * cycles; t += res {
			x := math.Sin(t)
			y := math.Sin(freq * t + phase)
			img.SetColorIndex(size + int(x * size + 0.5), size + int(y * size + 0.5), greenIndex)
		}
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
		phase += 0.1
	}
	gif.EncodeAll(w, &anim)
}

// 下面处理输入参数的问题
func main(){
	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler(w http.ResponseWriter, r *http.Request){
	if err:= r.ParseForm(); err != nil{
		log.Print(err)
		return
	}

	cyclesParam := r.Form.Get("cycles")
	if cyclesParam == ""{

	}else{
		cycleInt, error := strconv.Atoi(cyclesParam)
		if error != nil{
			fmt.Printf("transferring parameter: ", error)
			return
		}
		cycles = float64(cycleInt)
		lissajour(w)
	}
}```                                                                                                                                                                               可以观察到对于 os.Stdout, 无法直接输出类似 %q 类型，利用 r.Form 的切片和 Get 方法获取字符串，但不适合在os.Stdout 上输出，适合直接输出到浏览器 http.ResponseWriter

[esheeper]

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

// Server1 is a minimal "echo" server.
package main

import (
"fmt"
"image"
"image/color"
"image/gif"
"io"
"log"
"math"
"math/rand"
"net/http"
"sync"
)

var count int
var mu sync.RWMutex

func main() {
http.HandleFunc("/counter", counter)
http.HandleFunc("/", index)
http.HandleFunc("/gif", genGif)
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func index(res http.ResponseWriter, req *http.Request) {
fmt.Println("request path:", req.URL.Path)
if req.URL.Path != "/" {
return
}
mu.Lock()
count++
mu.Unlock()
fmt.Fprintf(res, "%s %s %s %s\n", req.Method, req.URL.Path, req.URL, req.Proto)
for k, v := range req.Header {
fmt.Fprintf(res, "Header[%q] = %q\n", k, v)
}
fmt.Fprintf(res, "Host = %q\n", req.Host)
fmt.Fprintf(res, "RemoteAddr = %q\n", req.RemoteAddr)
if err := req.ParseForm(); err != nil {
log.Print(err)
}
for k, v := range req.Form {
fmt.Fprintf(res, "Form[%q] = %q\n", k, v)
}
}

func counter(res http.ResponseWriter, req *http.Request) {
fmt.Println("Request '/counter'")
mu.RLock()
fmt.Fprintf(res, "Count %d\n", count)
mu.RUnlock()
}

func genGif(res http.ResponseWriter, req *http.Request) {
res.Header().Set("Content-Type", "image/gif")
lissajous(res)
}

func lissajous(out io.Writer) {
const (
cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)

var palette []color.Color
var sigma float32 = 255.0 / 64.0
for i := 0; i < 64; i++ {
	color_number := uint8(sigma * float32(i))
	palette = append(palette, color.RGBA{color_number, color_number, color_number, 0xff})
}
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
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),
			uint8(i))
	}
	phase += 0.1
	anim.Delay = append(anim.Delay, delay)
	anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors

}

[w2807]

package main

import (
	"fmt"
	"image"
	"image/color"
	"image/gif"
	"io"
	"log"
	"math"
	"math/rand"
	"net/http"
	"strconv"
	"sync"
	"time"
)

var mu sync.Mutex
var count int
var palette = []color.Color{color.White, color.Black}
var rnd = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))

const (
	whiteIndex = 0
	blackIndex = 1
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		lissajous(w, r)
	})
	http.HandleFunc("/count", counter)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func counter(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	fmt.Fprintf(w, "Count %d\n", count)
	mu.Unlock()
}

func lissajous(out io.Writer, r *http.Request) {
	mu.Lock()
	count++
	mu.Unlock()
	var cycle = r.FormValue("cycles")
	cycles, err := strconv.Atoi(cycle)
	if err != nil {
		cycles = 5
	}
	const (
		res     = 0.001
		size    = 100
		nframes = 64
		delay   = 8
	)
	freq := rand.Float64() * 3.0
	anim := gif.GIF{LoopCount: nframes}
	phase := 0.0
	for range nframes {
		rect := image.Rect(0, 0, 2*size+1, 2*size+1)
		img := image.NewPaletted(rect, palette)
		for t := 0.0; t < float64(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),
				blackIndex)
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim)
}