准备工作

为什么要从实例学习go语言？

我认为，从实例来学习一门编程语言，把编程语言各个重要的知识点通过例子展现出来，更加生动形象，对刚接触go语言的程序员来讲是最佳的选择。你不可能拿本编程宝典在那生啃是吧！肯定要动手参与敲代码的实践当中才有最好的学习效果。

为什么要写这篇文章？

记录我认为会比较容易忘记的知识点，适当补充，整理总结，以及自己的心得体会。适合初入go语言的小白和已经有部分go基础的复习参考。

学习地址

两个 Go 教程平台 github 项目地址

两个 Go 教程平台部署地址（使用这个）

如果文章字体过小，请调整浏览器页面缩放。Windows： Ctrl + 鼠标滚轮

注意：本篇文章代码注释使用了 vscode 的 better-comments 拓展，具体请看

[个人配置] VSCode Better Comments 扩展配置、高亮注释插件

练习答案

Go 指南里有部分练习题，下面是我写的答案，点击跳转

练习：循环与函数 “牛顿法实现平方根函数”
练习：切片 “生成嵌套切片用于产生图像”
练习：映射 “映射字符串中单词个数”
练习：斐波纳契闭包 “使用闭包返回斐波纳契数列”
练习：Stringer “实现字符串输出接口”
练习：错误 “实现错误接口”
练习：Reader “产生’A’的无限流”
练习：rot13Reader “数据流修改”
练习：图像 “实现Image接口产生图像”

主要内容

包、变量、函数、流程控制、数组、结构体、切片、映射、面向对象、接口，基础知识与进阶知识。

不包含并发内容，后面会起一篇文章专门写Go并发。已更新并发内容

资料下载

部分代码：2020_3/Basics.zip

基础知识

包的使用

导入包并使用

每个 Go 程序都是由包构成的。

程序从 main 包开始运行。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

package mainimport (
    "fmt"
    "math/rand"
)func main() {
    fmt.Println("My favorite number is", rand.Intn(10))
}

产生随机数每次都一样

此程序的运行环境是固定的，因此 rand.Intn 总是会返回相同的数字。（要得到不同的数字，需为生成器提供不同的种子数)

我们编写如下代码，第一次直接使用 rand 生成随机数，第二次通过时间戳生成一个种子提供给生成器获得 r 生成器对象，再通过 r 生成随机数。如果看不懂可略先跳过，具体会在随机数章节讲到。

package mainimport (
    "fmt"
    "math/rand"
    "time"
)func main() {
    // ^ 因为运行环境固定,返回的随机数永远是固定值
    fmt.Println("第一次 我最喜欢的数字")
    fmt.Println("第一个数字", rand.Intn(10))
    fmt.Println("第二个数字", rand.Intn(10))
    fmt.Println("第三个数字", rand.Intn(10))    // ^ 使用时间戳生成一个种子重置化 rand
    seed := rand.NewSource(time.Now().Unix())
    r := rand.New(seed)    // ^ 再生成随机数
    fmt.Println("第二次 我最喜欢的数字")
    fmt.Println("第一个数字", r.Intn(10))
    fmt.Println("第二个数字", r.Intn(10))
    fmt.Println("第三个数字", r.Intn(10))
}

可以发现，无论运行多少次，第一次三个数字都是一样的，而第二次三个数字是变化的。

第一次 我最喜欢的数字
第一个数字 1
第二个数字 7
第三个数字 7
第二次 我最喜欢的数字
第一个数字 7
第二个数字 0
第三个数字 7

因为运行环境是固定的，使用 rand 标准库，如果不给定新的种子，那么程序每次运行生成的随机数都是一样的。

导入多个包

// ^ 第一种方式
import "fmt"
import "math"// ^ 第二种方式
import (
"fmt"
"math"
)

导出名（公开、Public）

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

将首字母大写，类似 Java、C# 中的 Public 修饰符，称为公共函数、变量，其他包能够使用。小写称为私有函数、变量，类似 Java、C# 中的 private 修饰符，只能在内部使用。

目录结构：
└───2_Public
    │   main.go
    │
    ├───hello
    │       hello.go
    │
    └───world
            world.go

hello.go

package helloimport "fmt"var PI float64 = 3.1415926
var Count int = 1
var count int = 1func Hello() {
    fmt.Println("Hello")
}func hello() {
    fmt.Println("hello")
}func world() {
    fmt.Println("World")
}

world.go

package worldfunc World() {
    println("World")
}

main.go

package mainimport (
    "Work/Work/Study/Basics/2_Public/hello"
    w "Work/Work/Study/Basics/2_Public/world"
    "fmt"
)func main() {
    fmt.Println("导出名的使用")
    fmt.Println(hello.PI)
    hello.Hello()
    // ^ 在 import 中对 world 包起别名 w
    w.World()
}

可以看到只有大写开头的函数或变量标识符能被其他包使用。

函数

函数写法

要注意 go 语言的函数参数类型要写在形参后面。

package mainimport "fmt"func add(x int, y int) int {
    return x + y
}func main() {
    fmt.Println(add(42, 13))
}

形参类型相同

当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略。

func add(x, y int) int {
    return x + y
}

返回多个值

函数可以返回任意数量的返回值。

func swap(x, y string) (string, string) {
    return y, x
}func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

没有参数的return

Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。

没有参数的 return 语句返回已命名的返回值。也就是 直接 返回。

直接返回语句应当仅用在短的函数中。在长的函数中它们会影响代码的可读性。

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}func main() {
    fmt.Println(split(17))
}

变量

变量命名

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。var 语句可以出现在包或函数级别。

package mainimport "fmt"var c, python, java boolfunc main() {
    var i int
    fmt.Println(i, c, python, java)
}

从初始值获取类型

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。

基本类型

boolstringint  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptrbyte // uint8 的别名rune // int32 的别名
    // 表示一个 Unicode 码点float32 float64complex64 complex128

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。

当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

你可以像import那样分组成一个语法块声明并初始化变量。

var (
    ToBe   bool       = false
    MaxInt uint64     = 1<<63
    z      complex128 = cmplx.Sqrt(-5 + 12i)
)

零值

如果你没有明确初始化变量则会自动赋予零值。

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}//0 0 false ""

类型转换

这点有点类似 python 的类型转换。表达式 T(v) 将值 v 转换为类型 T。

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)i := 42
f := float64(i)
u := uint(f)

Go 在不同类型的项之间赋值时需要显式转换。

类型推导

声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同。

var i int
j := i // j 也是一个 int

当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度。

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

例如，用类型转换或浮点数语法来声明并初始化一个浮点数值。

z := 1.0
z := float64(1)

常量

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

数值常量

数值常量是高精度的值。

一个未指定类型的常量由上下文来决定其类型。

int 可以存放最大64位的整数，根据平台不同有时会更少。

const (
    // 将 1 左移 100 位来创建一个非常大的数字
    // 即这个数的二进制是 1 后面跟着 100 个 0
    Big = 1 << 100
    // 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
    Small = Big >> 99
)func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
    return x * 0.1
}func main() {
    fmt.Println(needInt(Small))
    fmt.Println(needFloat(Small))
    fmt.Println(needFloat(Big))
}

21
0.2
1.2676506002282295e+29

可以看到没有使用 needInt(Big) 是因为 Int 最多只能存储 64 位的整数，而我们传入的形参已经到了 2^100 , 所以用精度更高的 float64 完成

流程控制

for 循环

Go 唯一的循环结构，由三部分组成，跟其他语言一样。不用写圆括号，必须要写花括号！

初始化语句：在第一次迭代前执行。初始化语句通常为一句短变量声明
条件表达式：在每次迭代前求值。一旦条件表达式的布尔值为 false，循环迭代就会终止。
后置语句：在每次迭代的结尾执行

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

初始化语句、后置语句可选

func main() {
    sum := 1
    for ; sum < 1000; {
        sum += sum
    }
    fmt.Println(sum)
}

while 循环（for 实现）

上面的代码，去掉分号， C 的 while 在 Go 中叫做 for。

func main() {
    sum := 1
    for sum < 1000{
        sum += sum
    }
    fmt.Println(sum)
}

死循环

func main() {
    for {
    }
}

if 判断

package mainimport (
    "fmt"
    "math"
)func sqrt(x float64) string {
    if x < 0 {
        return sqrt(-x) + "i"
    }
    return fmt.Sprint(math.Sqrt(x))
}func main() {
    fmt.Println(sqrt(2), sqrt(-4))
}

fmt.Sprint 格式化字符串

fmt.Sprintf(格式化样式, 参数列表…)

格式化样式：字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。
参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

完整列表参考：https://www.jianshu.com/p/66aaf908045e

格式	描述
%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示
%c	输出单个字符
%s	输出字符串
%q	双引号围绕的字符串，由Go语法安全地转义
%g	小数不为0则显示小数，小数点右侧的0不显示

package mainimport (
    "fmt"
)type point struct {
    x, y int
}func main() {
    // go 中格式化字符串并赋值给新串，使用 fmt.Sprintf
    // %s 表示字符串
    var stockcode = "000987"
    var enddate = "2020-12-31"
    var url = "Code=%s&endDate=%s"
    var target_url = fmt.Sprintf(url, stockcode, enddate)
    fmt.Println(target_url)    // 另外一个实例，%d 表示整型
    const name, age = "Kim", 22 // 常量不能用 := 语法声明
    s := fmt.Sprintf("%s is %d years old.\n", name, age)
    fmt.Println(s)    p := point{1, 2}
    fmt.Printf("%v\n", p)
    fmt.Printf("%+v\n", p)
    fmt.Printf("%#v\n", p)
    fmt.Printf("%T\n", p)
    fmt.Printf("%t\n", true)
    fmt.Printf("%d\n", 123)
    fmt.Printf("%b\n", 14)
    fmt.Printf("%c\n", 33)
    fmt.Printf("%x\n", 456)
    fmt.Printf("%f\n", 78.9)
    fmt.Printf("%g\n", 78.9) // ^ 这个很好用
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)
    fmt.Printf("%s\n", "\"string\"")
    fmt.Printf("%q\n", "\"string\"")
    fmt.Printf("%x\n", "hex this")
    fmt.Printf("%p\n", &p)
    fmt.Printf("|%6d|%6d|\n", 12, 345) // ^ 默认右对齐
    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
    fmt.Printf("|%6s|%6s|\n", "foo", "b")
    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
    ss := fmt.Sprintf("a %s", "string")
    fmt.Println(ss)
}

Code=000987&endDate=2020-12-31
Kim is 22 years old.{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
123
1110
!
1c8
78.900000
78.9
1.234000e+08
1.234000E+08
"string"
"\"string\""
6865782074686973
0xc0000160c0
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string

if 简短语句

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    }
    return lim
}func main() {
    fmt.Println(
        pow(3, 2, 10),
        pow(3, 3, 20),
    )
}

如果将 pow 函数最后的 return lim 改为 return v 则会报错 undefined: v。切记作用域仅在 if else 内部

if 和 else

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    // 这里开始就不能使用 v 了
    return lim
}

%g 格式符

12.3+12.7如果使用%f输出，你将会得到25.000000，而有的时候你并不想要小数点末尾这么多的0，你可能会选择强制转换成int类型，但是这样子会显得有点繁琐，这个时候%g的妙用就体现出来了，使用%g格式符输出之后，直接得到25了，它会自动将小数点后面没用的0过滤掉。

‘g’使用小写字母，’G’使用大写字母。小数点右侧的尾数0不被显示；显示小数点仅当输出的小数部分不为0。

练习：循环与函数

题目地址：https://tour.go-zh.org/flowcontrol/8

为了练习函数与循环，我们来实现一个平方根函数：用牛顿法实现平方根函数。

计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始，我们可以根据 z² 与 x 的近似度来调整 z，产生一个更好的猜测

z -= (z*z - x) / (2*z)

重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。

在提供的 func Sqrt 中实现它。无论输入是什么，对 z 的一个恰当的猜测为 1。要开始，请重复计算 10 次并随之打印每次的 z 值。观察对于不同的值 x（1、2、3 …），你得到的答案是如何逼近结果的，猜测提升的速度有多快。

func Sqrt(x float64) float64 {
    z := 1.0 // ^ 给定类型浮点数值
    for math.Abs(z*z-x) > 0.000001 {
        z -= (z*z - x) / (2 * z)
        fmt.Println(z)
    }
    return z
}func main() {
    fmt.Println(Sqrt(2))
}

1.5
1.4166666666666667
1.4142156862745099
1.4142135623746899
1.4142135623746899

Switch

Go 的 switch 语句类似于 C、C++、Java、JavaScript 中的，不过 Go 只运行选定的 case，而非之后所有的 case。实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

func main() {
    fmt.Print("Go runs on ")
    switch os := runtime.GOOS; os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        // plan9, windows...
        fmt.Printf("%s.\n", os)
    }
}

switch 条件前可以写赋值表达式，作用域在 switch 内部

求值顺序

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

如下代码，在 i==0 时 f 不会被调用。

switch i {
case 0:
case f():
}

判断距离星期六还有多久

func main() {
    fmt.Println("When's Saturday?")
    today := time.Now().Weekday()
    switch time.Saturday {
    case today + 0:
        fmt.Println("Today.")
    case today + 1:
        fmt.Println("Tomorrow.")
    case today + 2:
        fmt.Println("In two days.")
    default:
        fmt.Println("Too far away.")
    }
}

没有条件

相当于 switch true { …… }

func main() {
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("Good morning!")
    case t.Hour() < 17:
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }
}

优点是能将一长串 if-then-else 写得更加清晰

Defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

func main() {
    defer fmt.Println("world")    fmt.Println("hello")
}

hello
world

Defer 栈

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

func main() {
    fmt.Println("counting")    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }    fmt.Println("done")
}

counting
done
2
1
0

数据结构

指针

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

& 操作符会生成一个指向其操作数的指针。即获取变量的内存地址

* 操作符表示指针指向的底层值。

func main() {
    i := 42
    p := &i
    fmt.Println(p)
    fmt.Println(*p)
    *p = 21
    fmt.Println(p)
    fmt.Println(*p)
}

0xc000016088
42
0xc000016088
21

注意 Go 没有指针运算，像 p = p + 1 会导致错误

结构体

定义、访问结构体

一个结构体（struct）就是一组字段（field）。

结构体字段可以使用点号来访问。

type Vertex struct {
    X int
    Y int
}func main() {
    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
}

结构体字段可以通过结构体指针来访问。

type Vertex struct {
    X int
    Y int
}func main() {
    v := Vertex{1, 2}
    p := &v
    p.X = 1e9 // 科学计数法
    fmt.Println(v)
}

{1000000000 2}

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，Go 允许我们使用隐式间接引用，直接写 p.X 就可以。

结构体文法

结构体文法通过使用 Name: 语法直接列出字段的值来新分配一个结构体。

特殊的前缀 & 返回一个指向结构体的指针。

type Vertex struct {
    X, Y int
}var (
    v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
    v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
    v3 = Vertex{}      // X:0 Y:0
    p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)func main() {
    fmt.Println(v1, p, v2, v3)
}

{1 2} &{1 2} {1 0} {0 0}

数组

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

var a [10]int

数组的长度是其类型的一部分，因此数组不能改变大小。

func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)    primes := [6]int{2, 3, 5, 7, 11, 13}
    fmt.Println(primes)
}

Hello World
[Hello World]
[2 3 5 7 11 13]

切片 Slice

声明切片

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。

[]T 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔

a[low : high]

它会选择一个半开区间，包括第一个元素，但排除最后一个元素。

func main() {
    primes := [6]int{2, 3, 5, 7, 11, 13}    var s []int = primes[1:4]
    fmt.Println(s)
}

[3 5 7]

切片如同数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。

func main() {
    names := [4]string{
        "John",
        "Paul",
        "George",
        "Ringo",
    }
    fmt.Println(names)    a := names[0:2]
    b := names[1:3]
    fmt.Println(a, b)    b[0] = "XXX"
    fmt.Println(a, b)
    fmt.Println(names)
}

[John Paul George Ringo]
[John Paul] [Paul George]
[John XXX] [XXX George]
[John XXX George Ringo]

更改切片的元素会修改其底层数组中对应的元素，与它共享底层数组的切片都会观测到这些修改。

切片文法

[3]bool{true, true, false} // 数组文法
[]bool{true, true, false} // 切片文法，创建一个和上面相同的数组，然后构建一个引用了它的切片

func main() {
    q := []int{2, 3, 5, 7, 11, 13}
    fmt.Println(q)    r := []bool{true, false, true, true, false, true}
    fmt.Println(r)    s := []struct {
        i int
        b bool
    }{
        {2, true},
        {3, false},
        {5, true},
        {7, true},
        {11, false},
        {13, true},
    }
    fmt.Println(s)
}

[2 3 5 7 11 13]
[true false true true false true]
[{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]

我们可以在切片声明的时候定义结构体

s := []struct {
        i int
        b bool
    }{
        {2, true},
        {3, false}
     }

截取默认行为

切片下界的默认值为 0，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的

a[0:10]
a[:10]
a[0:]
a[:]

切片的长度与容量

切片拥有长度和容量。

切片的长度就是它所包含的元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

你可以通过重新切片来扩展一个切片，给它提供足够的容量。

package mainimport "fmt"func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    printSlice(s)    // 截取切片使其长度为 0
    s = s[:0]
    printSlice(s)    // 拓展其长度
    s = s[:4]
    printSlice(s)    // 舍弃前两个值
    s = s[2:]
    printSlice(s)
}func printSlice(s []int) {
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

我们看到从前面裁剪（舍弃元素）会改变切片容量，从后面裁剪（舍弃元素）则不改变切片容量

nil 切片零值

切片的零值是 nil。

nil 切片的长度和容量为 0 且没有底层数组。

func main() {
    var s []int
    fmt.Println(s, len(s), cap(s))
    if s == nil {
        fmt.Println("nil!")
    }
}

[] 0 0
nil!

make 创建切片

切片可以用内建函数 make 来创建，也是创建动态数组的方式。

make 函数会分配一个元素为零值的数组并返回一个引用了它的切片

a := make([]int, 5)  // len(a)=5
b := make([]int, 0, 5) // len(b)=0, cap(b)=5
// 注意看 len 的变化
b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

func main() {
    a := make([]int, 5)
    printSlice("a", a)    b := make([]int, 0, 5)
    printSlice("b", b)    c := b[:2]
    printSlice("c", c)    d := c[2:5]
    printSlice("d", d)
}func printSlice(s string, x []int) {
    fmt.Printf("%s len=%d cap=%d %v\n",
        s, len(x), cap(x), x)
}

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0]
d len=3 cap=3 [0 0 0]

切片的切片

切片可包含任何类型，甚至包括其它的切片。

func main() {
    // 创建一个井字板（经典游戏）
    board := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
    }    // 两个玩家轮流打上 X 和 O
    board[0][0] = "X"
    board[2][2] = "O"
    board[1][2] = "X"
    board[1][0] = "O"
    board[0][2] = "X"    for i := 0; i < len(board); i++ {
        fmt.Printf("%s\n", strings.Join(board[i], " "))
    }
}

X _ X
O _ X
_ _ O

strings.Join(board[i], " ") 使用间隔符“ ”合并切片数组元素返回一个字符串

向切片追加元素

func append(s []T, vs ...T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。

append 的结果是一个包含原切片所有元素加上新添加元素的切片。

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

func main() {
    var s []int
    printSlice(s)    // 添加一个空切片
    s = append(s, 0)
    printSlice(s)    // 这个切片会按需增长
    s = append(s, 1)
    printSlice(s)    // 可以一次性添加多个元素
    s = append(s, 2, 3, 4)
    printSlice(s)
}func printSlice(s []int) {
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

len=0 cap=0 []
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=5 cap=6 [0 1 2 3 4]

Range

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

var pow = []int{1, 2, 4, 8, 16}func main() {
    for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
    }
}

2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16

使用 _ 忽略值

可以将下标或值赋予 _ 来忽略它。若你只需要索引，忽略第二个变量即可。

for i, _ := range pow
for _, value := range pow
for i := range pow

遍历切片，使用下标、位运算符进行切片元素赋值

func main() {
    pow := make([]int, 3)
    for i := range pow {
        pow[i] = 1 << uint(i) // == 2**i
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
}

1
2
4

练习：切片

题目地址：https://tour.go-zh.org/moretypes/18

实现 Pic。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值（好吧，其实是蓝度值）并显示它所对应的图像。

图像的选择由你来定。几个有趣的函数包括 (x+y)/2, x*y, x^y, x*log(y) 和 x%(y+1)。

（提示：需要使用循环来分配 [][]uint8 中的每个 []uint8；请使用 uint8(intValue) 在类型之间转换；你可能会用到 math 包中的函数。）

第一种写法

package mainimport "golang.org/x/tour/pic"func Pic(dx, dy int) [][]uint8 {
    res := make([][]uint8, dy)
    for i := 0; i < dy; i++ {
        temp := make([]uint8, dx)
        for i := 0; i < dx; i++ {
            temp[i] = uint8(i)
        }
        res[i] = temp // ^ res = append(res, temp) 这个是添加
    }
    return res
}func main() {
    pic.Show(Pic)
}

第二种写法

package mainimport "golang.org/x/tour/pic"func Pic(dx, dy int) [][]uint8 {
    res := make([][]uint8, 0, dy)
    for j := 0; j < dy; j++ {
        res = append(res, make([]uint8, dx))
        for k := 0; k < dx; k++ {
            res[j][k] = uint8(j+k)/2
        }
    }
    return res
}func main() {
    pic.Show(Pic)
}

映射 Map

映射声明与使用

映射将键映射到值。

映射的零值为 nil 。nil 映射既没有键，也不能添加键。

make 函数会返回给定类型的映射，并将其初始化备用。

映射的文法与结构体相似，不过必须有键名。

package mainimport "fmt"type Vertex struct {
    Lat, Long float64
}var m map[string]Vertexvar n = map[string]Vertex{
    "Bell Labs": Vertex{
        40.68433, -74.39967,
    },
    "Google": Vertex{
        37.42202, -122.08408,
    },
}func main() {
    m = make(map[string]Vertex)
    m["Bell Labs"] = Vertex{
        40.68433, -74.39967,
    }
    fmt.Println(m["Bell Labs"])
   fmt.Println(n["Google"])
}

{40.68433 -74.39967}
{37.42202 -122.08408}

若顶级类型只是一个类型名，你可以在文法的元素中省略它。

var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}

修改映射

在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

通过双赋值检测某个键是否存在（因为不存在默认也返回零值，要根据第二个参数判断）

elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false。

若 key 不在映射中，那么 elem 是该映射元素类型的零值。

同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

注：若 elem 或 ok 还未声明，你可以使用短变量声明：

elem, ok := m[key]

func main() {
    m := make(map[string]int)    m["Answer"] = 42
    fmt.Println("The value:", m["Answer"])    m["Answer"] = 48
    fmt.Println("The value:", m["Answer"])    delete(m, "Answer")
    fmt.Println("The value:", m["Answer"])    v, ok := m["Answer"]
    fmt.Println("The value:", v, "Present?", ok)
}

The value: 42
The value: 48
The value: 0
The value: 0 Present? false

练习：映射

题目地址：https://tour.go-zh.org/moretypes/23

实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败。

你会发现 strings.Fields 很有帮助。

strings.Fields 相当于 "……".split(' ') 根据空格分割字符串返回一个字符串数组

package mainimport (
    "strings"    "golang.org/x/tour/wc"
)func WordCount(s string) map[string]int {
    res := make(map[string]int)
    words := strings.Fields(s)
    for i := 0; i < len(words); i++ {
        word := words[i]
        res[word] += 1
    }
    return res
}func main() {
    wc.Test(WordCount)
}

PASS
 f("I am learning Go!") =
  map[string]int{"Go!":1, "I":1, "am":1, "learning":1}
PASS
 f("The quick brown fox jumped over the lazy dog.") =
  map[string]int{"The":1, "brown":1, "dog.":1, "fox":1, "jumped":1, "lazy":1, "over":1, "quick":1, "the":1}
PASS
 f("I ate a donut. Then I ate another donut.") =
  map[string]int{"I":2, "Then":1, "a":1, "another":1, "ate":2, "donut.":2}
PASS
 f("A man a plan a canal panama.") =
  map[string]int{"A":1, "a":2, "canal":1, "man":1, "panama.":1, "plan":1}

函数值

作为参数或返回值

函数也是值。它们可以像其它值一样传递。

函数值可以用作函数的参数或返回值。

func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(hypot(5, 12))    fmt.Println(compute(hypot))
    fmt.Println(compute(math.Pow))
}

13
5
81

计时器包装

写一个包装函数添加运行计时功能的函数

func main() {
    myFunc := AddTimer(MyFor)
    myFunc()
}func MyFor() bool {
    sum := 0
    for i := 0; i < 1000000000; i++ {
        sum += i
    }
    return true
}func AddTimer(fn func() bool) func() bool {
    return func() bool {
        start := time.Now()
        result := fn()
        totalTime := time.Since(start)
        fmt.Println("共耗时", totalTime)
        return result
    }
}

共耗时 1.4966547s 秒

time.Since() 函数返回从 t 到现在经过的时间，等价于time.Now().Sub(t)

闭包

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起。

例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 4; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}

练习：斐波纳契闭包

题目地址：https://tour.go-zh.org/moretypes/26

// 返回一个“返回int的函数”
func fibonacci() func() int {
    a,b,c := 0,1,0
    return func() int{
        c = a
        a,b = b,a+b
        return c
    }
}func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

进阶知识

面向对象

对象方法（值接收者）

Go 没有类。不过你可以为结构体类型定义方法。

func ( 接收者 ) FuncName ( args... ) Return Type

方法就是一类带特殊的 接收者 参数的函数。通俗的来讲就是把方法绑定到这个结构体下。

方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。

在此例中，Abs 方法拥有一个名为 v，类型为 Vertex 的接收者。

type Vertex struct {
    X, Y float64
}func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())
}

记住：方法只是个带接收者参数的函数。

你也可以为非结构体类型声明方法。我们对 float64 起一个别名 MyFloat

在此例中，我们看到了一个带 Abs 方法的数值类型 MyFloat。

type MyFloat float64func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}func main() {
    f := MyFloat(-math.Sqrt2)
    fmt.Println(f.Abs())
}

你只能为在同一包内定义的类型的接收者声明方法，而不能为其它包内定义的类型（包括 int 之类的内建类型）的接收者声明方法。

总结：接收者的类型定义和方法声明必须在同一包内；不能为内建类型声明方法。（所以上面为 float64 起了别名）

对象方法（指针接收者）

你可以为指针接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 不能是像 *int 这样的指针。）

例如，这里为 *Vertex 定义了 Scale 方法。

指针接收者的方法可以修改接收者指向的值（就像 Scale 在这做的）。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。

若使用值接收者，那么 Scale 方法会对原始 Vertex 值的副本进行操作。（对于函数的其它参数也是如此。）Scale 方法必须用指针接受者来更改 main 函数中声明的 Vertex 的值。

type Vertex struct {
    X, Y float64
}func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}func main() {
    v := Vertex{3, 4}
    v.Scale(10)
    fmt.Println(v.Abs())
}

方法与指针重定向

我们将上述 Scale 对象方法写成普通函数。

type Vertex struct {
    X, Y float64
}func Scale(v *Vertex, f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}func main() {
    v := Vertex{3, 4}
    v.Scale(2)
    ScaleFunc(&v, 10)    p := &Vertex{4, 3}
    p.Scale(3)
    ScaleFunc(p, 8)    fmt.Println(v, p)
}

{60 80} &{96 72}

可以注意到带指针参数的函数必须接受一个指针

var v Vertex
ScaleFunc(v, 5)  // 编译错误！
ScaleFunc(&v, 5) // OK

而以指针为接收者的方法被调用时，接收者既能为值又能为指针

var v Vertex
v.Scale(5)  // OK
p := &v
p.Scale(10) // OK

v.Scale(10) 会被解析成 (&v).Scale(10)

选择值或指针作为接收者

使用指针接收者的原因有二个：

首先，方法能够修改其接收者指向的值。

其次，这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效。

在本例中，Scale 和 Abs 接收者的类型为 *Vertex，即便 Abs 并不需要修改其接收者。

通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。

接口

接口定义

接口类型 是由一组方法签名定义的集合。

接口类型的变量可以保存任何实现了这些方法的值。

type Abser interface {
    Abs() float64
}func main() {
    var a Abser
    f := MyFloat(-math.Sqrt2)
    v := Vertex{3, 4}    a = f  // a MyFloat 实现了 Abser
    a = &v // a *Vertex 实现了 Abser    // 下面一行，v 是一个 Vertex（而不是 *Vertex）
    // 所以没有实现 Abser。
    a = v    fmt.Println(a.Abs())
}

./prog.go:22:6: cannot use v (variable of type Vertex) as type Abser in assignment:
    Vertex does not implement Abser (Abs method has pointer receiver)

会报错，由于 Abs 方法只为 *Vertex （指针类型）定义，因此 Vertex（值类型）并未实现 Abser。

func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

接口与隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements”关键字。

隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。

因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

type I interface {
    M()
}type T struct {
    S string
}// 此方法表示类型 T 实现了接口 I，但我们无需显式声明此事。
func (t T) M() {
    fmt.Println(t.S)
}func main() {
    var i I = T{"hello"}
    i.M()
}

通俗的说，就是我实现了某个接口的方法集合，我不需要像 Java、C# 写上根据的接口名称。无需显式声明。

接口值

接口也是值。它们可以像其它值一样传递。

接口值可以用作函数的参数或返回值。

在内部，接口值可以看做包含值和具体类型的元组：(value, type) =(底层值, 底层值类型)

接口值保存了一个具体底层类型的具体值。

接口值调用方法时会执行其底层类型的同名方法。

package mainimport (
    "fmt"
    "math"
)type I interface {
    M()
}type T struct {
    S string
}func (t *T) M() {
    fmt.Println(t.S)
}type F float64func (f F) M() {
    fmt.Println(f)
}func main() {
    var i I    i = &T{"Hello"}
    describe(i)
    i.M()    i = F(math.Pi)
    describe(i)
    i.M()
}func describe(i I) {
    fmt.Printf("(%v, %T)\n", i, i)
}

(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793

底层值为 nil 的接口值

即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。

注意: 保存了 nil 具体值的接口其自身并不为 nil。

type I interface {
    M()
}type T struct {
    S string
}func (t *T) M() {
    if t == nil {
        fmt.Println("<nil>")
        return
    }
    fmt.Println(t.S)
}func main() {
    var i I    var t *T
    i = t
    describe(i)
    i.M()    i = &T{"hello"}
    describe(i)
    i.M()
}func describe(i I) {
    fmt.Printf("(%v, %T)\n", i, i)
}

(<nil>, *main.T)
<nil>
(&{hello}, *main.T)
hello

nil 接口值

nil 接口值既不保存值也不保存具体类型。

为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。

type I interface {
    M()
}func main() {
    var i I
    describe(i)
    i.M()
}func describe(i I) {
    fmt.Printf("(%v, %T)\n", i, i)
}

(<nil>, <nil>)
panic: runtime error: invalid memory address or nil pointer dereference

空接口

指定了零个方法的接口值被称为 *空接口：*

interface{}

空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）

空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

func main() {
    var i interface{}
    describe(i)    i = 42
    describe(i)    i = "hello"
    describe(i)
}func describe(i interface{}) {
    fmt.Printf("(%v, %T)\n", i, i)
}

(<nil>, <nil>)
(42, int)
(hello, string)

类型断言

类型断言方式

类型断言 提供了访问接口值底层具体值的方式。

t := i.(T)

该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。

若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。

为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。

t, ok := i.(T)

若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。

否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生恐慌。

请注意这种语法和读取一个映射时的相同之处。

func main() {
    var i interface{} = "hello"    s := i.(string)
    fmt.Println(s)    s, ok := i.(string)
    fmt.Println(s, ok)    f, ok := i.(float64)
    fmt.Println(f, ok)    f = i.(float64) // 报错(panic)
    fmt.Println(f)
}

hello
hello true
0 false
panic: interface conversion: interface {} is string, not float64

类型选择

类型选择 是一种按顺序从几个类型断言中选择分支的结构。

类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

switch v := i.(type) {
case T:
    // v 的类型为 T
case S:
    // v 的类型为 S
default:
    // 没有匹配，v 与 i 的类型相同
}

类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。

此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。

func do(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Twice %v is %v\n", v, v*2)
    case string:
        fmt.Printf("%q is %v bytes long\n", v, len(v))
    default:
        fmt.Printf("I don't know about type %T!\n", v)
    }
}func main() {
    do(21)
    do("hello")
    do(true)
}

Twice 21 is 42
"hello" is 5 bytes long
I don't know about type bool!

Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

type Stringer interface {
    String() string
}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

type Person struct {
    Name string
    Age  int
}func (p Person) String() string {
    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}func main() {
    a := Person{"Arthur Dent", 42}
    z := Person{"Zaphod Beeblebrox", 9001}
    fmt.Println(a, z)
}

Arthur Dent (42 years)
Zaphod Beeblebrox (9001 years)

可以看做是 fmt.Println(i Stringer){……} 只要实现了 Stringer 方法集合的类型都可以传入进去，Person结构体实现了 String() 方法，实现了 Stringer 接口

练习：Stringer

练习地址：https://tour.go-zh.org/methods/18

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。

例如，IPAddr{1, 2, 3, 4} 应当打印为 "1.2.3.4"。

package mainimport (
    "fmt"
)type IPAddr [4]byte// TODO: 给 IPAddr 添加一个 "String() string" 方法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)
    }
}func (ip IPAddr) String() string {
    return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
}

loopback: 127.0.0.1
googleDNS: 8.8.8.8

错误

Go 程序使用 error 值来表示错误状态。

与 fmt.Stringer 类似，error 类型是一个内建接口：

type error interface {
    Error() string
}

（与 fmt.Stringer 类似，fmt 包在打印值时也会满足 error。）

通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。

i, err := strconv.Atoi("42")
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}
fmt.Println("Converted integer:", i)

error 为 nil 时表示成功；非 nil 的 error 表示失败。

package mainimport (
    "fmt"
    "time"
)type MyError struct {
    When time.Time
    What string
}func (e *MyError) Error() string {
    return fmt.Sprintf("at %v, %s",
        e.When, e.What)
}func run() error {
    return &MyError{
        time.Now(),
        "it didn't work",
    }
}func main() {
    if err := run(); err != nil {
        fmt.Println(err)
    }
}

at 2009-11-10 23:00:00 +0000 UTC m=+0.000000001, it didn't work

Run 函数返回一个 MyError 类型的指针，MyError 类型实现了 error 内建接口，所以可以写成 func run() error

练习：错误

题目地址：https://tour.go-zh.org/methods/20

从之前的练习中复制 Sqrt 函数，修改它使其返回 error 值。

Sqrt 接受到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新的类型

type ErrNegativeSqrt float64

并为其实现

func (e ErrNegativeSqrt) Error() string

方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 "cannot Sqrt negative number: -2"。

注意: 在 Error 方法内调用 fmt.Sprint(e) 会让程序陷入死循环。可以通过先转换 e 来避免这个问题：fmt.Sprint(float64(e))。这是为什么呢？

修改 Sqrt 函数，使其接受一个负数时，返回 ErrNegativeSqrt 值。

package mainimport (
    "fmt"
    "math"
)type ErrNegativeSqrt float64func Sqrt(x float64) (float64, error) {
    // ^ 假如小于 0 直接返回
    if x < 0 {
        return x, ErrNegativeSqrt(x)
    }
    z := 1.0 // ^ 给定类型浮点数值
    for math.Abs(z*z-x) > 0.000001 {
        z -= (z*z - x) / (2 * z)
        fmt.Println(z)
    }
    return z, nil
}// ^ ErrNegativeSqrt 实现了 error 接口
func (e ErrNegativeSqrt) Error() string {
    return fmt.Sprintf("cannot Sqrt negative number: %g", e)
}func main() {
    fmt.Println(Sqrt(2))
    fmt.Println(Sqrt(-2))
}

1.5
1.4166666666666667
1.4142156862745099
1.4142135623746899
1.4142135623746899 <nil>
-2 cannot Sqrt negative number: -2

Reader

io 包指定了 io.Reader 接口，它表示从数据流的末尾进行读取。

Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader 接口有一个 Read 方法：

func (T) Read(b []byte) (n int, err error)

Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。

示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。

func main() {
    r := strings.NewReader("Hello, Reader!")    b := make([]byte, 8)
    for {
        n, err := r.Read(b)
        fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
        fmt.Printf("b[:n] = %q\n", b[:n])
        if err == io.EOF {
            break
        }
    }
}

n = 8 err = <nil> b = [72 101 108 108 111 44 32 82]
b[:n] = "Hello, R"
n = 6 err = <nil> b = [101 97 100 101 114 33 32 82]
b[:n] = "eader!"
n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
b[:n] = ""

读一部分处理一部分，无限循环，直到读完为止退出。

练习：Reader

练习地址：https://tour.go-zh.org/methods/22

实现一个 Reader 类型，它产生一个 ASCII 字符 'A' 的无限流。

package mainimport "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{})
}

相当于每次读取的时候，都是返回一个二进制数组，其中有一个ASCII字符‘A’，返回错误为 nil，不输出 io.EOF 会导致永远读不完 = 无限流。等同下方。（’A’的ASCII值为65）

n = 1 err = nil b = [65,...]
b[:n] = "A"
n = 1 err = nil b = [65,...]
b[:n] = "A"
n = 1 err = nil b = [65,...]
b[:n] = "A"

练习：rot13Reader

题目地址：https://tour.go-zh.org/concurrency/10

有种常见的模式是一个 io.Reader 包装另一个 io.Reader，然后通过某种方式修改其数据流。

例如，gzip.NewReader 函数接受一个 io.Reader（已压缩的数据流）并返回一个同样实现了 io.Reader 的 *gzip.Reader（解压后的数据流）。

编写一个实现了 io.Reader 并从另一个 io.Reader 中读取数据的 rot13Reader，通过应用 rot13 代换密码对数据流进行修改。

rot13Reader 类型已经提供。实现 Read 方法以满足 io.Reader。

什么是 ROT13

ROT13（“旋转 13 位”，有时连字符ROT-13）是一种简单的字母替换密码，用字母表中的第 13 个字母替换一个字母。ROT13 是在古罗马发展起来的凯撒密码的一个特例。

因为基本拉丁字母有26个字母（2×13），所以ROT13是它自己的逆；也就是说，为了撤销ROT13，应用相同的算法，因此可以使用相同的动作进行编码和解码。该算法几乎不提供加密安全性，并且经常被引用为弱加密的典型示例。

例如，HELLO成为URYYB（或相反，再次URYYB成为HELLO）。

答案

思路：n是第14个字母，所以加密解密都会变成第1个字母。当 ASCII 值大于等于 ‘N’ 或 ‘n’ 时减去13，如 ‘N’ -> ‘A’，当 ASCII 值小于 ‘N’ 或 ‘n’ 时加上13，如 ‘B’ -> ‘O’。

package mainimport (
    "io"
    "os"
    "strings"
)type rot13Reader struct {
    r io.Reader
}func (rot13 rot13Reader) Read(b []byte) (int, error) {
    n, err := rot13.r.Read(b)
    if err != nil {
        return 0, nil
    }
    for i := 0; i < n; i++ {
        switch {
        case 'Z' >= b[i] && b[i] >= 'N' || 'z' >= b[i] && b[i] >= 'n':
            b[i] = b[i] - 13
        case 'N' > b[i] && b[i] >= 'A' || 'n' > b[i] && b[i] >= 'a':
            b[i] = b[i] + 13
        default:
        }
    }
    return n, err
}func main() {
    s := strings.NewReader("Lbh penpxrq gur pbqr!")
    r := rot13Reader{s}
    io.Copy(os.Stdout, &r)
}

You cracked the code!

图像

image 包定义了 Image 接口：

package imagetype Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

注意: Bounds 方法的返回值 Rectangle 实际上是一个 image.Rectangle，它在 image 包中声明。

（请参阅文档了解全部信息。）

color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由 image/color 包定义。

package mainimport (
    "fmt"
    "image"
)func main() {
    m := image.NewRGBA(image.Rect(0, 0, 100, 100))
    fmt.Println(m.Bounds())
    fmt.Println(m.At(0, 0).RGBA())
}

(0,0)-(100,100)
0 0 0 0

相当于你定义了一个图形, bounds() 是图像边界两个点，At() 查找某点像素点，然后 RGBA() 输出颜色信息

练习：图像

题目地址：https://tour.go-zh.org/methods/25

还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 image.Image 的实现而非一个数据切片。

定义你自己的 Image 类型，实现必要的方法（实现 Image 接口）并调用 pic.ShowImage。

Bounds 应当返回一个 image.Rectangle ，例如 image.Rect(0, 0, w, h)。

ColorModel 应当返回 color.RGBAModel。

At 应当返回一个颜色。上一个图片生成器的值 v 对应于此次的 color.RGBA{v, v, 255, 255}。

这道题第一次看有点蒙蔽，回到前面看 image 包的 Image 接口

type Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

题目的意思就是给定一个空结构体让我们实现 Image 接口的所有方法。

colorModel() 返回 color.RGBAModel ，是一个对象，它实现了 color.Model 接口
At(x, y int) 返回 color.RGBA{} ，是一个结构体，它实现了 color.Color 接口，声明该结构体需要注意转换参数值类型

package mainimport (
    "image"
    "image/color"    "golang.org/x/tour/pic"
)type Image struct{}func (img Image) ColorModel() color.Model {
    return color.RGBAModel
}func (img Image) Bounds() image.Rectangle {
    return image.Rect(0, 0, 100, 100)
}func (img Image) At(a, b int) color.Color {
    return color.RGBA{uint8(a), uint8(b), uint8(a + b/2), 255}
}func main() {
    m := Image{}
    pic.ShowImage(m)
}

看这幻彩色的图像，编程真有趣，本篇就到这里了，大家继续加油！