网站首页 > 基础教程 正文
编码的实现环境是go1.15.6、LiteIDE X37.3、win7。是《Go语言圣经》的练习及作业，个别代码有修改，仅供交流学习之用。
// Dup1 prints the text of each line that appears more than once in the standard input, preceded by its count.
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
counts := make(map[string]int)
input := bufio.NewScanner(os.Stdin)
fmt.Println("inputs:", input)
for input.Scan() {
// 下面语句等价于
// line := input.Text()
// counts[line] = counts[line] + 1
counts[input.Text()]++
}
fmt.Println("counts:", counts)
// NOTE: ignoring potential errors from input.Err()
for line, n := range counts {
if n > 1 {
fmt.Printf("wo:%d\t%s\n", n, line)
}
}
}// Dup2 prints the count and text of lines that appear more than once in the input.
// It reads from stdin or from a list of named files.
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
counts := make(map[string]int)
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)
continue
}
countLines(f, counts)
f.Close()
}
}
for line, n := range counts {
if n > 1 {
fmt.Printf("后面：%d\t%s\n", n, line)
}
}
}
func countLines(f *os.File, counts map[string]int) {
input := bufio.NewScanner(f)
// fmt.Println(input)
for input.Scan() {
// fmt.Println("前", counts)
counts[input.Text()]++
if counts[input.Text()] == counts[input.Text()]++ {
fmt.Println(f)
}
fmt.Println("后", counts) // 逐行显示文件内容
}
// NOTE: ignoring potential errors from input.Err()
}// Dup3 一次性把文件的全部输入数据读到内存中，一次分割为多行，然后处理它们。
// 引入了ReadFile函数（来自于io/ioutil包），其读取指定文件的全部内容，strings.Split函数把字符串分割成子串的切片。
package main
import (
"io/ioutil"
"fmt"
"os"
"strings"
)
func main() {
counts := make(map[string]int)
for _, filename := range os.Args[1:] {
data, err := ioutil.ReadFile(filename) // ReadFile函数返回一个字节切片（byte slice）
if err != nil {
fmt.Fprintf(os.Stderr, "dup3: %v\n", err)
continue
}
// ReadFile函数返回一个字节切片（byte slice），必须把它转换为string，才能用strings.Split分割。
for _, line := range strings.Split(string(data), "\n") {
counts[line]++
}
}
for line, n := range counts {
fmt.Println(line, n)
if n > 1 {
fmt.Printf("%d\t%s\n", n, line)
}
}
}// Lissajous generates GIF animations of random Lissajous figures.
// 执行语句： go run lissajous > out.gif
package main
import (
"image"
"image/color"
"image/gif"
"io"
"math"
"math/rand"
"os"
"time"
)
// var palette = []color.Color{color.White, color.Black} // 复合声明，生成一个slice切片
var palette = []color.Color{color.RGBA{255, 180, 0, 255}, color.RGBA{0, 255, 0, 255}} // 将面板设置为绿色 color.RGBA{0xRR, 0xGG, 0xBB, 0xff}
const (
whiteIndex = 0 // first color in palette
blackIndex = 1 // next color in palette
)
func main() {
// The sequence of images is deterministic unless we seed the pseudo-random number generator using the current time.
rand.Seed(time.Now().UTC().UnixNano())
lissajous(os.Stdout)
}
func lissajous(out io.Writer) {
const (
cycles = 5 // 完整的x振荡转数 number of complete x oscillator revolutions
res = 0.001 // 角分辨率 angular resolution
size = 200 // 图像画布封面[-size..+size] image canvas covers [-size..+size]
nframes = 64 // 动画帧数 number of animation frames
delay = 8 // //以10ms为单位的帧间延迟 delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // y振荡器的相对频率 relative frequency of y oscillator
// 复合声明，生成一个struct结构体。struct是一组值或者叫字段的集合，不同的类型集合在一个struct可以让我们以一个统一的单元进行处理。
// 内部字段会被设置为各自类型默认的零值。struct内部的变量可以以一个点（.）来进行访问。
anim := gif.GIF{LoopCount: nframes} // 其内部变量LoopCount字段会被设置为nframes；
phase := 0.0 // 相位差 phase difference
// 外循环会循环64次，每一次都会生成一个单独的动画帧。它生成了一个包含两种颜色的201*201大小的图片，白色和黑色。
// 所有像素点都会被默认设置为其零值（也就是调色板palette里的第0个值），这里我们设置的是白色。每次外层循环都会生成一张新图片，并将一些像素设置为黑色。
// 其结果会append到之前结果之后。将结果append到anim中的帧列表末尾，并设置一个默认的80ms的延迟值。
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2 * size + 1, 2 * size + 1)
img := image.NewPaletted(rect, palette)
// 内循环设置两个偏振值。x轴偏振使用sin函数。y轴偏振也是正弦波，但其相对x轴的偏振是一个0-3的随机值，初始偏振值是一个零值，随着动画的每一帧逐渐增加。
// 循环会一直跑到x轴完成五次完整的循环。每一步它都会调用SetColorIndex来为(x,y)点来染黑色。
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图片中，并将结果写入到输出流。out这个变量是io.Writer类型，这个类型支持把输出结果写到很多目标。
gif.EncodeAll(out, &anim)
}// Fetch prints the content found at a URL.
// 执行语句： go run fetch.go https://www.baidu.com
package main
import (
"fmt"
"io"
// "io/ioutil"
"net/http"
"os"
"strings"
)
func main() {
for _, url := range os.Args[1:] {
ret := strings.HasPrefix(url, "https://")
if ret == false {
url = "https://" + url
}
resp, err := http.Get(url)
fmt.Println("http状态码：", resp.Status)
if err != nil {
fmt.Fprintf(os.Stderr, "fetch error: %v\n", err)
os.Exit(1)
}
// b, err := ioutil.ReadAll(resp.Body)
// 将上述代码利用io.Copy方法实现
dst := os.Stdout
b, err := io.Copy(dst, resp.Body)
resp.Body.Close()
if err != nil {
fmt.Fprintf(os.Stderr, "fetch: reading $s: %v\n", url, err)
os.Exit(1)
}
fmt.Printf("%s", b)
}
}// Fetchall fetches URLs in parallel and reports their times and sizes.
// 执行语句： go run fetchall.go https://www.baidu.com
package main
import (
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"time"
)
func main() {
start := time.Now()
ch := make(chan string) // 用make函数创建了一个传递string类型参数的channel
for _, url := range os.Args[1:] {
go fetch(url, ch) // 创建一个goroutine，并且让函数在这个goroutine异步执行http.Get方法。start a goroutine
}
for range os.Args[1:] {
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) // start a goroutine
return
}
nbytes, err := io.Copy(ioutil.Discard, resp.Body) // io.Copy会把响应的Body内容拷贝到ioutil.Discard输出流中
resp.Body.Close() // don't leak resources
if err != nil {
ch <- fmt.Sprintf("当读取 %s: %v 时", url, err)
return
}
secs := time.Since(start).Seconds()
ch <- fmt.Sprintf("%.2sf %7d %s", secs, nbytes, url)
}// Server1 is a minimal "echo" server.
// 执行语句： go run server1.go http://localhost:8000
// 在浏览器里输入http://localhost:8000，观察结果。
package main
import (
"fmt"
"log"
"net/http"
)
// main函数将所有发送到/路径下的请求和handler函数关联起来，/开头的请求其实就是所有发送到当前站点上的请求，服务监听8000端口。
func main() {
http.HandleFunc("/", handler) // each request calls handler
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}
// 发送到这个服务的“请求”是一个http.Request类型的对象，这个对象中包含了请求中的一系列相关字段，其中包括URL。
// 当请求到达服务器时，这个请求会被传给handler函数来处理，函数会将/hello这个路径从请求的URL中解析出来，然后把其发送到响应中，这里用标准输出流的fmt.Fprintf。
// handler echoes the Path component of the request URL r.
func handler(w http.ResponseWriter, r * http.Request) {
fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}// Server2 is a minimal "echo" and counter server.
// 执行语句： go run server1.go http://localhost:8000
// 在浏览器里输入http://localhost:8000，观察结果。
package main
import (
"fmt"
"log"
"net/http"
"sync"
)
var mu sync.Mutex
var count int
// main函数将所有发送到/路径下的请求和handler函数关联起来，/开头的请求其实就是所有发送到当前站点上的请求，服务监听8000端口。
// 这个服务器有两个请求处理函数，根据请求的url不同会调用不同的函数：对/count这个url的请求会调用到counter这个函数，其它的url都会调用默认的处理函数。
// 如果你的请求pattern是以/结尾，那么所有以该url为前缀的url都会被这条规则匹配。
func main() {
http.HandleFunc("/", handler) // each request calls handler
http.HandleFunc("/count", counter)
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}
// 发送到这个服务的“请求”是一个http.Request类型的对象，这个对象中包含了请求中的一系列相关字段，其中包括URL。
// 当请求到达服务器时，这个请求会被传给handler函数来处理，函数会将/hello这个路径从请求的URL中解析出来，然后把其发送到响应中，这里用标准输出流的fmt.Fprintf。
// handler echoes the Path component of the request URL.
// 服务器每一次接收请求处理时都会另起一个goroutine，这样服务器就可以同一时间处理多个请求。
// 然而在并发情况下，假如真的有两个请求同一时刻去更新count，那么这个值可能并不会被正确地增加；这个程序可能会引发一个严重的bug：竞态条件（参见9.1）。
// 为了避免这个问题，必须保证每次修改变量的最多只能有一个goroutine，所以通过调用mu.Lock()和mu.Unlock()将修改count的所有行为包在中间。
func handler(w http.ResponseWriter, r *http.Request) {
mu.Lock()
count++
mu.Unlock()
fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}
// counter echoes the number of calls so far.
func counter(w http.ResponseWriter, r *http.Request) {
mu.Lock()
fmt.Fprintf(w, "count %d\n", count)
mu.Unlock()
}// Server3 is an "echo" server that displays request parameters.
// 执行语句： go run server3.go
// 在浏览器里输入http://localhost:8000，观察结果。
package main
import (
"fmt"
"log"
"net/http"
"image"
"image/color"
"image/gif"
"math"
"math/rand"
"io"
)
// main函数将所有发送到/路径下的请求和handler函数关联起来，/开头的请求其实就是所有发送到当前站点上的请求，服务监听8000端口。
func main() {
//
handler := func(w http.ResponseWriter, r *http.Request) {
lissajous(w)
}
http.HandleFunc("/", handler) // each request calls handler
log.Fatal(http.ListenAndServe("localhost:8000", nil))
}
// handler函数会把请求的http头和请求的form数据都打印出来，这样可以使检查和调试这个服务更为方便
// 发送到这个服务的“请求”是一个http.Request类型的对象，这个对象中包含了请求中的一系列相关字段，其中包括URL。
// 当请求到达服务器时，这个请求会被传给handler函数来处理，函数会将/hello这个路径从请求的URL中解析出来，然后把其发送到响应中，这里用标准输出流的fmt.Fprintf。
// handler echoes the Path component of the request URL.
func handler(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)
// 下面这里的ParseForm()被嵌套在了if语句中，也可以分成两行写。用if和ParseForm结合可以让代码更加简单，并且可以限制err这个变量的作用域。
if err := r.ParseForm(); err != nil {
log.Print(err)
}
for k, v := range r.Form {
fmt.Fprintf(w, "Form[%q] = %q\n", k, v)
}
}
var palette = []color.Color{color.White, color.Black} // 复合声明，生成一个slice切片
const (
whiteIndex = 0 // first color in palette
blackIndex = 1 // next color in palette
)
func lissajous(out io.Writer) {
const (
cycles = 5 // 完整的x振荡转数 number of complete x oscillator revolutions
res = 0.001 // 角分辨率 angular resolution
size = 200 // 图像画布封面[-size..+size] image canvas covers [-size..+size]
nframes = 64 // 动画帧数 number of animation frames
delay = 8 // //以10ms为单位的帧间延迟 delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // y振荡器的相对频率 relative frequency of y oscillator
// 复合声明，生成一个struct结构体。struct是一组值或者叫字段的集合，不同的类型集合在一个struct可以让我们以一个统一的单元进行处理。
// 内部字段会被设置为各自类型默认的零值。struct内部的变量可以以一个点（.）来进行访问。
anim := gif.GIF{LoopCount: nframes} // 其内部变量LoopCount字段会被设置为nframes；
phase := 0.0 // 相位差 phase difference
// 外循环会循环64次，每一次都会生成一个单独的动画帧。它生成了一个包含两种颜色的201*201大小的图片，白色和黑色。
// 所有像素点都会被默认设置为其零值（也就是调色板palette里的第0个值），这里我们设置的是白色。每次外层循环都会生成一张新图片，并将一些像素设置为黑色。
// 其结果会append到之前结果之后。将结果append到anim中的帧列表末尾，并设置一个默认的80ms的延迟值。
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2 * size + 1, 2 * size + 1)
img := image.NewPaletted(rect, palette)
// 内循环设置两个偏振值。x轴偏振使用sin函数。y轴偏振也是正弦波，但其相对x轴的偏振是一个0-3的随机值，初始偏振值是一个零值，随着动画的每一帧逐渐增加。
// 循环会一直跑到x轴完成五次完整的循环。每一步它都会调用SetColorIndex来为(x,y)点来染黑色。
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图片中，并将结果写入到输出流。out这个变量是io.Writer类型，这个类型支持把输出结果写到很多目标。
gif.EncodeAll(out, &anim)
}猜你喜欢
- 2024-11-26 golang defer、panic、recover实践
- 2024-11-26 go-fastdfs文件上传
- 2024-11-26 OpenHarmony3.0在树莓派3B上的烧录与通讯
- 2024-11-26 go|bytes.buffer
- 2024-11-26 AOVX资产跟踪产品测试工具mPower1203如何使用python对接 (二)
- 2024-11-26 Python os.dup2() 方法是什么?os.du
- 2024-11-26 go中关于文件和json操作的知识点小结
- 2024-11-26 python3从零学习-5.8.4、mmap—内存映射文件支持
- 2024-11-26 29.Python 读取文件的六种方式
- 2024-11-26 macOS安装并设置五笔输入法
- 最近发表
- 标签列表
-
- gitpush (61)
- pythonif (68)
- location.href (57)
- tail-f (57)
- pythonifelse (59)
- deletesql (62)
- c++模板 (62)
- css3动画 (57)
- c#event (59)
- linuxgzip (68)
- 字符串连接 (73)
- nginx配置文件详解 (61)
- html标签 (69)
- c++初始化列表 (64)
- exec命令 (59)
- canvasfilltext (58)
- mysqlinnodbmyisam区别 (63)
- arraylistadd (66)
- node教程 (59)
- console.table (62)
- c++time_t (58)
- phpcookie (58)
- mysqldatesub函数 (63)
- window10java环境变量设置 (66)
- c++虚函数和纯虚函数的区别 (66)