【Go学习】-01-3-函数 结构体 接口 IO

---

1 函数

1.1 函数概述

函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段，其可以提高应用的模块性和代码的重复利用率。

Go 语言支持普通函数、匿名函数和闭包，从设计上对函数进行了优化和改进，让函数使用起来更加方便。

Go 语言的函数属于“一等公民”（first-class），也就是说：

• 函数本身可以作为值进行传递。
• 支持匿名函数和闭包（closure）。
• 函数可以满足接口。

函数定义:

func function_name( [parameter list] ) [return_types] {函数体
}

• func：函数由 func 开始声明
• function_name：函数名称，函数名和参数列表一起构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。

示例：

package mainimport "fmt"func main() {fmt.Println(max(1, 10))fmt.Println(max(-1, -2))
}
//类型相同的相邻参数，参数类型可合并。
func max(n1, n2 int) int {if n1 > n2 {return n1}return n2
}

Go语言是编译型语言，所以函数编写的顺序是无关紧要的，鉴于可读性的需求，最好把 main() 函数写在文件的前面，其他函数按照一定逻辑顺序进行编写（例如函数被调用的顺序）。

返回值可以为多个：

func test(x, y int, s string) (int, string) {// 类型相同的相邻参数，参数类型可合并。 多返回值必须用括号。n := x + y          return n, fmt.Sprintf(s, n)
}

1.1.1 函数做为参数

函数做为一等公民，可以做为参数传递。

func test(fn func() int) int {return fn()
}
func fn()  int{return 200
}
func main() {//这是直接使用匿名函数s1 := test(func() int { return 100 }) //这是传入一个函数s1 := test(fn)fmt.Println(s1)
}

在将函数做为参数的时候，我们可以使用类型定义，将函数定义为类型，这样便于阅读

// 定义函数类型。
type FormatFunc func(s string, x, y int) stringfunc format(fn FormatFunc, s string, x, y int) string {return fn(s, x, y)
}
func formatFun(s string,x,y int) string  {return fmt.Sprintf(s,x,y)
}
func main() {s2 := format(formatFun,"%d, %d",10,20)fmt.Println(s2)
}

有返回值的函数，必须有明确的终止语句，否则会引发编译错误。

1.1.2 函数返回值

函数返回值可以有多个，同时Go支持对返回值命名

//多个返回值 用括号扩起来
func sum(a,b int) (int,int)  {return a,b
}
func main(){a,b := sum(2,3)fmt.Println(a,b)
}

package mainimport "fmt"
//支持返回值 命名 ，默认值为类型零值,命名返回参数可看做与形参类似的局部变量,由return隐式返回
func f1() (names []string, m map[string]int, num int) {m = make(map[string]int)m["k1"] = 2return
}func main() {a, b, c := f1()fmt.Println(a, b, c)
}

1.2 参数

函数定义时指出，函数定义时有参数，该变量可称为函数的形参。

形参就像定义在函数体内的局部变量。

但当调用函数，传递过来的变量就是函数的实参，函数可以通过两种方式来传递参数：

1. 值传递：指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

   func swap(x, y int) int {... ...
   }
   

2. 引用传递：是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

   package mainimport ("fmt"
   )/* 定义相互交换值的函数 */
   func swap(x, y *int) {*x,*y = *y,*x
   }func main() {var a, b int = 1, 2/*调用 swap() 函数&a 指向 a 指针，a 变量的地址&b 指向 b 指针，b 变量的地址*/swap(&a, &b)fmt.Println(a, b)
   }
   

在默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。

注意2：map、slice、chan、指针、interface默认以引用的方式传递。

不定参数传值

不定参数传值 就是函数的参数不是固定的，后面的类型是固定的。（可变参数）

Golang 可变参数本质上就是 slice。只能有一个，且必须是最后一个。

在参数赋值时可以不用用一个一个的赋值，可以直接传递一个数组或者切片。

格式:

func myfunc(args ...int) { //0个或多个参数
}func add1(a int, args ...int){ //1个或多个参数
}func add2(a int, b int, args ...int){ //2个或多个参数
}

注意：其中args是一个slice，我们可以通过arg[index]依次访问所有参数,通过len(arg)来判断传递参数的个数.

package mainimport ("fmt"
)func test(s string, n ...int) string {var x intfor _, i := range n {x += i}return fmt.Sprintf(s, x)
}func main() {s := []int{1, 2, 3}res := test("sum: %d", s...)    // slice... 展开sliceprintln(res)
}

1.3 匿名函数

匿名函数是指不需要定义函数名的一种函数实现方式。

在Go里面，函数可以像普通变量一样被传递或使用，Go语言支持随时在代码里定义匿名函数。

匿名函数由一个不带函数名的函数声明和函数体组成。匿名函数的优越性在于可以直接使用函数内的变量，不必声明。

匿名函数的定义格式如下：

func(参数列表)(返回参数列表){函数体
}

示例：

package mainimport ("fmt""math"
)func main() {//这里将一个函数当做一个变量一样的操作。getSqrt := func(a float64) float64 {return math.Sqrt(a)}fmt.Println(getSqrt(4))
}

在定义时调用匿名函数

匿名函数可以在声明后调用，例如：

func(data int) {fmt.Println("hello", data)
}(100) //(100)，表示对匿名函数进行调用，传递参数为 100。

匿名函数用作回调函数

匿名函数作为回调函数的设计在Go语言也比较常见

package main
import ("fmt"
)
// 遍历切片的每个元素, 通过给定函数进行元素访问
func visit(list []int, f func(int)) {for _, v := range list {f(v)}
}
func main() {// 使用匿名函数打印切片内容visit([]int{1, 2, 3, 4}, func(v int) {fmt.Println(v)})
}

返回多个匿名函数

package mainimport "fmt"func FGen(x, y int) (func() int, func(int) int) {//求和的匿名函数sum := func() int {return x + y}// (x+y) *z 的匿名函数avg := func(z int) int {return (x + y) * z}return sum, avg
}func main() {f1, f2 := FGen(1, 2)fmt.Println(f1())fmt.Println(f2(3))
}

1.4 闭包

所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。

闭包=函数+引用环境

示例：

package main
import ("fmt"
)
// 创建一个玩家生成器, 输入名称, 输出生成器
func playerGen(name string) func() (string, int) {// 血量一直为150hp := 150// 返回创建的闭包return func() (string, int) {// 将变量引用到闭包中return name, hp}
}// 创建一个玩家生成器, 输入名称, 输出生成器
func playerGen1() func(string) (string, int) {// 血量一直为150hp := 150// 返回创建的闭包return func(name string) (string, int) {// 将变量引用到闭包中return name, hp}
}
func main() {// 创建一个玩家生成器generator := playerGen("ms")// 返回玩家的名字和血量name, hp := generator()// 打印值fmt.Println(name, hp)generator1 := playerGen1()name1,hp1 := generator1("ms")// 打印值fmt.Println(name1, hp1)
}

1.5 延迟调用

Go语言的 defer 语句会将其后面跟随的语句进行延迟处理

defer特性:

1. 关键字 defer 用于注册延迟调用。
2. 这些调用直到 return 前才被执。因此，可以用来做资源清理。
3. 多个defer语句，按先进后出的方式执行。
4. defer语句中的变量，在defer声明时就决定了。

defer的用途：

1. 关闭文件句柄
2. 锁资源释放
3. 数据库连接释放

go 语言的defer功能强大，对于资源管理非常方便，但是如果没用好，也会有陷阱。

package mainimport "fmt"func main() {var whatever = [5]int{1, 2, 3, 4, 5}for index, num := range whatever {defer fmt.Printf("index:%d,num:%d\n", index, num)}
}

输出

index:4,num:5
index:3,num:4
index:2,num:3
index:1,num:2
index:0,num:1

看下面的示例：

package mainimport ("log""time"
)func main() {start := time.Now()log.Printf("开始时间为：%v", start)defer log.Printf("时间差：%v", time.Since(start)) // Now()此时已经copy进去了//不受这3秒睡眠的影响time.Sleep(10 * time.Second)log.Printf("函数结束")
}

输出

2025/01/02 13:34:02 开始时间为：2025-01-02 13:34:02.1849024 +0800 CST m=+0.005739301
2025/01/02 13:34:12 函数结束
2025/01/02 13:34:12 时间差：28.404ms

• Go 语言中所有的函数调用都是传值的
• 调用 defer 关键字会立刻拷贝函数中引用的外部参数 ，包括start 和time.Since中的Now
• defer的函数在压栈的时候也会保存参数的值，并非在执行时取值。

如何解决上述问题：使用defer fun()

package mainimport ("log""time"
)func main() {start := time.Now()log.Printf("开始时间为：%v", start)defer func() {log.Printf("开始调用defer")log.Printf("时间差：%v", time.Since(start))log.Printf("结束调用defer")}()time.Sleep(10 * time.Second)log.Printf("函数结束")
}

输出

2025/01/02 13:35:12 开始时间为：2025-01-02 13:35:12.6260682 +0800 CST m=+0.004025901
2025/01/02 13:35:22 函数结束
2025/01/02 13:35:22 开始调用defer
2025/01/02 13:35:22 时间差：10.025141s
2025/01/02 13:35:22 结束调用defer

因为拷贝的是函数指针,函数属于引用传递

在来看一个问题：

package mainimport "fmt"func main() {var whatever = [5]int{1,2,3,4,5}for i,_ := range whatever {//函数正常执行,由于闭包用到的变量 i 在执行的时候已经变成4,所以输出全都是4.defer func() { fmt.Println(i) }()}
}

闭包中的 i 是对循环变量的引用，而不是值拷贝。由于 defer 语句是延迟执行的，它们会在 for 循环结束后才被执行。到那个时候，循环变量 i 的值已经变成了 4（因为循环最后一次的索引值是4）。

怎么解决：

package mainimport "fmt"func main() {var whatever = [5]int{1,2,3,4,5}for i,_ := range whatever {i := idefer func() { fmt.Println(i) }()}
}

或者

package mainimport "fmt"func main() {var whatever = [5]int{1,2,3,4,5}for i,_ := range whatever {defer func(i int) { fmt.Println(i) }(i)}
}

1.6 异常处理

Go语言中使用 panic 抛出错误，recover 捕获错误。

异常的使用场景简单描述：Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。

panic：

1. 内置函数
2. 假如函数F中书写了panic语句，会终止其后要执行的代码，在panic所在函数F内如果存在要执行的defer函数列表，按照defer的逆序执行
3. 返回函数F的调用者G，在G中，调用函数F语句之后的代码不会执行，假如函数G中存在要执行的defer函数列表，按照defer的逆序执行
4. 直到goroutine整个退出，并报告错误

recover：

1. 内置函数
2. 用来捕获panic，从而影响应用的行为

golang 的错误处理流程：当一个函数在执行过程中出现了异常或遇到 panic()，正常语句就会立即终止，然后执行 defer 语句，再报告异常信息，最后退出 goroutine。如果在 defer 中使用了 recover() 函数,则会捕获错误信息，使该错误信息终止报告。

注意:

1. 利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。
2. recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。
3. 多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。

package mainfunc main() {test()
}func test() {defer func() {if err := recover(); err != nil {println(err.(string)) // 将 interface{} 转型为具体类型。}}()panic("panic error!")
}

由于 panic、recover 参数类型为 interface{}，因此可抛出任何类型对象。

 func panic(v interface{})func recover() interface{}

延迟调用中引发的错误，可被后续延迟调用捕获，但仅最后一个错误可被捕获:

package mainimport "fmt"func test() {defer func() {// defer panic 会打印fmt.Println(recover())}()defer func() {panic("defer panic")}()panic("test panic")
}func main() {test()
}

输出

defer panic

如果需要保护代码段，可将代码块重构成匿名函数，如此可确保后续代码被执 ：

package mainimport "fmt"func test(x, y int) {var z intfunc() {defer func() {if recover() != nil {z = 888}}()panic("test panic")z = x / yreturn}()fmt.Printf("x / y = %d\n", z)
}func main() {test(2, 1)
}

除用 panic 引发中断性错误外，还可返回 error 类型错误对象来表示函数调用状态:

type error interface {Error() string
}

标准库 errors.New 和 fmt.Errorf 函数用于创建实现 error 接口的错误对象。通过判断错误对象实例来确定具体错误类型。

package mainimport ("errors""fmt"
)var ErrDivByZero = errors.New("division by zero")func div(x, y int) (int, error) {if y == 0 {return 0, ErrDivByZero}return x / y, nil
}func main() {defer func() {fmt.Println(recover())}()switch z, err := div(10, 0); err {case nil:println(z)case ErrDivByZero:panic(err)}
}

Go实现类似 try catch 的异常处理:

package mainimport "fmt"func Try(fun func(), handler func(interface{})) {defer func() {if err := recover(); err != nil {handler(err)}}()fun()
}func main() {Try(func() {panic("test panic")}, func(err interface{}) {fmt.Println(err)})
}

如何区别使用 panic 和 error 两种方式?

惯例是:导致关键流程出现不可修复性错误的使用 panic，其他使用 error。

2 结构体

Go语言可以通过自定义的方式形成新的类型，结构体就是这些类型中的一种复合类型，结构体是由零个或多个任意类型的值聚合成的实体，每个值都可以称为结构体的成员。

结构体成员也可以称为“字段”，这些字段有以下特性：

• 字段拥有自己的类型和值；
• 字段名必须唯一；
• 字段的类型也可以是结构体，甚至是字段所在结构体的类型。

使用关键字 type 可以将各种基本类型定义为自定义类型，基本类型包括整型、字符串、布尔等。结构体是一种复合的基本类型，通过 type 定义为自定义类型后，使结构体更便于使用。

结构体的定义格式如下：

type 类型名 struct {字段1 字段1类型字段2 字段2类型…
}

• 类型名：标识自定义结构体的名称，在同一个包内不能重复。
• struct{}：表示结构体类型，type 类型名 struct{}可以理解为将 struct{} 结构体定义为类型名的类型。
• 字段1、字段2……：表示结构体字段名，结构体中的字段名必须唯一。
• 字段1类型、字段2类型……：表示结构体各个字段的类型。

示例：

type Point struct {X intY int
}

颜色的红、绿、蓝 3 个分量可以使用 byte 类型:

type Color struct {R, G, B byte
}

结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存

2.1 实例化

实例化就是根据结构体定义的格式创建一份与格式一致的内存区域，结构体实例与实例间的内存是完全独立的。

基本的实例化形式:

结构体本身是一种类型，可以像整型、字符串等类型一样，以 var 的方式声明结构体即可完成实例化。

var ins T

T 为结构体类型，ins 为结构体的实例。

package mainimport "fmt"type Point struct {X intY int
}
func main() {//使用.来访问结构体的成员变量,结构体成员变量的赋值方法与普通变量一致。var p Pointp.X = 1p.Y = 2fmt.Printf("%v,x=%d,y=%d",p,p.X,p.Y )
}

package mainimport "fmt"type Point struct {X intY int
}
func main() {var p Point//p.X = 1//p.Y = 2//如果不赋值 结构体中的变量会使用零值初始化fmt.Printf("%v,x=%d,y=%d",p,p.X,p.Y )
}

package mainimport "fmt"type Point struct {X intY int
}
func main() {//可以使用var p = Point{X: 1,Y: 2,}var p = Point{1,2,}fmt.Printf("%v,x=%d,y=%d",p,p.X,p.Y )
}

创建指针类型的结构体：

Go语言中，还可以使用 new 关键字对类型（包括结构体、整型、浮点数、字符串等）进行实例化，结构体在实例化后会形成指针类型的结构体。

ins := new(T)

• T 为类型，可以是结构体、整型、字符串等。
• ins：T 类型被实例化后保存到 ins 变量中，ins 的类型为 *T，属于指针。

下面的例子定义了一个玩家（Player）的结构，玩家拥有名字、生命值和魔法值：

type Player struct{Name stringHealthPoint intMagicPoint int
}
tank := new(Player)
tank.Name = "ms"
tank.HealthPoint = 300

new 实例化的结构体实例在成员赋值上与基本实例化的写法一致。

取结构体的地址实例化:

在Go语言中，对结构体进行&取地址操作时，视为对该类型进行一次 new 的实例化操作，取地址格式如下：

ins := &T{}

其中：

• T 表示结构体类型。
• ins 为结构体的实例，类型为 *T，是指针类型。

示例：

package mainimport "fmt"type Command struct {Name    string    // 指令名称Var     *int      // 指令绑定的变量Comment string    // 指令的注释
}func newCommand(name string, varRef *int, comment string) *Command {return &Command{Name:    name,Var:     varRef,Comment: comment,}
}var version = 1
func main() {cmd := newCommand("version",&version,"show version",)fmt.Println(cmd)
}

2.2 匿名结构体

匿名结构体没有类型名称，无须通过 type 关键字定义就可以直接使用。

ins := struct {// 匿名结构体字段定义字段1 字段类型1字段2 字段类型2…
}{// 字段值初始化初始化字段1: 字段1的值,初始化字段2: 字段2的值,…
}

• 字段1、字段2……：结构体定义的字段名。
• 初始化字段1、初始化字段2……：结构体初始化时的字段名，可选择性地对字段初始化。
• 字段类型1、字段类型2……：结构体定义字段的类型。
• 字段1的值、字段2的值……：结构体初始化字段的初始值。

package main
import ("fmt"
)
// 打印消息类型, 传入匿名结构体
func printMsgType(msg *struct {id   intdata string
}) {// 使用动词%T打印msg的类型fmt.Printf("%T\n, msg:%v", msg,msg)
}
func main() {// 实例化一个匿名结构体msg := &struct {  // 定义部分id   intdata string}{  // 值初始化部分1024,"hello",}printMsgType(msg)
}

2.3 匿名字段

结构体可以包含一个或多个匿名（或内嵌）字段，即这些字段没有显式的名字，只有字段的类型是必须的，此时类型也就是字段的名字。

匿名字段本身可以是一个结构体类型，即结构体可以包含内嵌结构体。

Go语言中的继承是通过内嵌或组合来实现的，所以可以说，在Go语言中，相比较于继承，组合更受青睐。

package mainimport "fmt"type User struct {id   intname string
}type Manager struct {User
}func (self *User) ToString() string { // receiver = &(Manager.User)return fmt.Sprintf("User: %p, %v", self, self)
}func main() {m := Manager{User{1, "Tom"}}fmt.Printf("Manager: %p\n", &m)fmt.Println(m.ToString())
}

类似于重写的功能：

package mainimport "fmt"type User struct {id   intname string
}type Manager struct {Usertitle string
}func (self *User) ToString() string {return fmt.Sprintf("User: %p, %v", self, self)
}func (self *Manager) ToString() string {return fmt.Sprintf("Manager: %p, %v", self, self)
}func main() {m := Manager{User{1, "Tom"}, "Administrator"}fmt.Println(m.ToString())fmt.Println(m.User.ToString())
}

3 类方法

在Go语言中，结构体就像是类的一种简化形式，那么类的方法在哪里呢？

在Go语言中有一个概念，它和方法有着同样的名字，并且大体上意思相同，Go 方法是作用在接收器（receiver）上的一个函数，接收器是某种类型的变量，因此方法是一种特殊类型的函数。

接收器类型可以是（几乎）任何类型，不仅仅是结构体类型，任何类型都可以有方法，甚至可以是函数类型，可以是 int、bool、string 或数组的别名类型，但是接收器不能是一个接口类型，因为接口是一个抽象定义，而方法却是具体实现，如果这样做了就会引发一个编译错误invalid receiver type…

接收器也不能是一个指针类型，但是它可以是任何其他允许类型的指针。

一个类型加上它的方法等价于面向对象中的一个类

在Go语言中，类型的代码和绑定在它上面的方法的代码可以不放置在一起，它们可以存在不同的源文件中，唯一的要求是它们必须是同一个包的。

类型 T（或 T）上的所有方法的集合叫做类型 T（或 T）的方法集。

在面向对象的语言中，类拥有的方法一般被理解为类可以做的事情。在Go语言中“方法”的概念与其他语言一致，只是Go语言建立的“接收器”强调方法的作用对象是接收器，也就是类实例，而函数没有作用对象。

为结构体添加方法：

需求：将物品放入背包

面向对象的写法：

​ 将背包做为一个对象，将物品放入背包的过程作为“方法”

package mainimport "fmt"type Bag struct {items []int
}
func (b *Bag) Insert(itemid int) {b.items = append(b.items, itemid)
}
func main() {b := new(Bag)b.Insert(1001)fmt.Println(b.items)
}

(b*Bag) 表示接收器，即 Insert 作用的对象实例。每个方法只能有一个接收器

3.1 接收器

接收器的格式如下：

func (接收器变量 接收器类型) 方法名(参数列表) (返回参数) {函数体
}

• 接收器变量：接收器中的参数变量名在命名时，官方建议使用接收器类型名的第一个小写字母，而不是 self、this 之类的命名。例如，Socket 类型的接收器变量应该命名为 s，Connector 类型的接收器变量应该命名为 c 等。
• 接收器类型：接收器类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：格式与函数定义一致。

接收器根据接收器的类型可以分为指针接收器、非指针接收器，两种接收器在使用时会产生不同的效果，根据效果的不同，两种接收器会被用于不同性能和功能要求的代码中。

指针类型的接收器:

指针类型的接收器由一个结构体的指针组成，更接近于面向对象中的 this 或者 self。

由于指针的特性，调用方法时，修改接收器指针的任意成员变量，在方法结束后，修改都是有效的。

示例：

使用结构体定义一个属性（Property），为属性添加 SetValue() 方法以封装设置属性的过程，通过属性的 Value() 方法可以重新获得属性的数值，使用属性时，通过 SetValue() 方法的调用，可以达成修改属性值的效果：

package main
import "fmt"
// 定义属性结构
type Property struct {value int  // 属性值
}
// 设置属性值
func (p *Property) SetValue(v int) {// 修改p的成员变量p.value = v
}
// 取属性值
func (p *Property) Value() int {return p.value
}
func main() {// 实例化属性p := new(Property)// 设置值p.SetValue(100)// 打印值fmt.Println(p.Value())
}

非指针类型的接收器:

当方法作用于非指针接收器时，Go语言会在代码运行时将接收器的值复制一份，在非指针接收器的方法中可以获取接收器的成员值，但修改后无效。

点（Point）使用结构体描述时，为点添加 Add() 方法，这个方法不能修改 Point 的成员 X、Y 变量，而是在计算后返回新的 Point 对象，Point 属于小内存对象，在函数返回值的复制过程中可以极大地提高代码运行效率:

package main
import ("fmt"
)
// 定义点结构
type Point struct {X intY int
}
// 非指针接收器的加方法
func (p Point) Add(other Point) Point {// 成员值与参数相加后返回新的结构return Point{p.X + other.X, p.Y + other.Y}
}
func main() {// 初始化点p1 := Point{1, 1}p2 := Point{2, 2}// 与另外一个点相加result := p1.Add(p2)// 输出结果fmt.Println(result)
}

在计算机中，小对象由于值复制时的速度较快，所以适合使用非指针接收器，大对象因为复制性能较低，适合使用指针接收器，在接收器和参数间传递时不进行复制，只是传递指针。

3.2 类方法练习：二维矢量模拟玩家移动

在游戏中，一般使用二维矢量保存玩家的位置，使用矢量运算可以计算出玩家移动的位置，本例子中，首先实现二维矢量对象，接着构造玩家对象，最后使用矢量对象和玩家对象共同模拟玩家移动的过程。

实现二维矢量结构:

矢量是数学中的概念，二维矢量拥有两个方向的信息，同时可以进行加、减、乘（缩放）、距离、单位化等计算，在计算机中，使用拥有 X 和 Y 两个分量的 Vec2 结构体实现数学中二维向量的概念。

package main
import "math"
type Vec2 struct {X, Y float32
}
// 加
func (v Vec2) Add(other Vec2) Vec2 {return Vec2{v.X + other.X,v.Y + other.Y,}
}
// 减
func (v Vec2) Sub(other Vec2) Vec2 {return Vec2{v.X - other.X,v.Y - other.Y,}
}
// 乘 缩放或者叫矢量乘法，是对矢量的每个分量乘上缩放比，Scale() 方法传入一个参数同时乘两个分量，表示这个缩放是一个等比缩放
func (v Vec2) Scale(s float32) Vec2 {return Vec2{v.X * s, v.Y * s}
}
// 距离 计算两个矢量的距离，math.Sqrt() 是开方函数，参数是 float64，在使用时需要转换，返回值也是 float64，需要转换回 float32
func (v Vec2) DistanceTo(other Vec2) float32 {dx := v.X - other.Xdy := v.Y - other.Yreturn float32(math.Sqrt(float64(dx*dx + dy*dy)))
}
// 矢量单位化
func (v Vec2) Normalize() Vec2 {mag := v.X*v.X + v.Y*v.Yif mag > 0 {oneOverMag := 1 / float32(math.Sqrt(float64(mag)))return Vec2{v.X * oneOverMag, v.Y * oneOverMag}}return Vec2{0, 0}
}

实现玩家对象：

玩家对象负责存储玩家的当前位置、目标位置和速度，使用 MoveTo() 方法为玩家设定移动的目标，使用 Update() 方法更新玩家位置，在 Update() 方法中，通过一系列的矢量计算获得玩家移动后的新位置。

1. 使用矢量减法，将目标位置（targetPos）减去当前位置（currPos）即可计算出位于两个位置之间的新矢量
2. 使用 Normalize() 方法将方向矢量变为模为 1 的单位化矢量，这里需要将矢量单位化后才能进行后续计算
3. 获得方向后，将单位化方向矢量根据速度进行等比缩放，速度越快，速度数值越大，乘上方向后生成的矢量就越长（模很大）
4. 将缩放后的方向添加到当前位置后形成新的位置

package main
type Player struct {currPos   Vec2    // 当前位置targetPos Vec2    // 目标位置speed     float32 // 移动速度
}
// 移动到某个点就是设置目标位置
//逻辑层通过这个函数告知玩家要去的目标位置，随后的移动过程由 Update() 方法负责
func (p *Player) MoveTo(v Vec2) {p.targetPos = v
}
// 获取当前的位置
func (p *Player) Pos() Vec2 {return p.currPos
}//判断玩家是否到达目标点，玩家每次移动的半径就是速度（speed），因此，如果与目标点的距离小于速度，表示已经非常靠近目标，可以视为到达目标。
func (p *Player) IsArrived() bool {// 通过计算当前玩家位置与目标位置的距离不超过移动的步长，判断已经到达目标点return p.currPos.DistanceTo(p.targetPos) < p.speed
}
// 逻辑更新
func (p *Player) Update() {if !p.IsArrived() {// 计算出当前位置指向目标的朝向//数学中，两矢量相减将获得指向被减矢量的新矢量dir := p.targetPos.Sub(p.currPos).Normalize()// 添加速度矢量生成新的位置newPos := p.currPos.Add(dir.Scale(p.speed))// 移动完成后，更新当前位置p.currPos = newPos}
}
// 创建新玩家
func NewPlayer(speed float32) *Player {return &Player{speed: speed,}
}

处理移动逻辑：

将 Player 实例化后，设定玩家移动的最终目标点，之后开始进行移动的过程，这是一个不断更新位置的循环过程，每次检测玩家是否靠近目标点附近，如果还没有到达，则不断地更新位置，让玩家朝着目标点不停的修改当前位置，如下代码所示：

package main
import "fmt"func main() {// 实例化玩家对象，并设速度为0.5p := NewPlayer(0.5)// 让玩家移动到3,1点p.MoveTo(Vec2{3, 1})// 如果没有到达就一直循环for !p.IsArrived() {// 更新玩家位置p.Update()// 打印每次移动后的玩家位置fmt.Println(p.Pos())}fmt.Printf("到达了：%v",p.Pos())
}

3.3 给任意类型添加方法

Go语言可以对任何类型添加方法，给一种类型添加方法就像给结构体添加方法一样，因为结构体也是一种类型。

为基本类型添加方法：

在Go语言中，使用 type 关键字可以定义出新的自定义类型，之后就可以为自定义类型添加各种方法了。我们习惯于使用面向过程的方式判断一个值是否为 0，例如：

if  v == 0 {// v等于0
}

如果将 v 当做整型对象，那么判断 v 值就可以增加一个 IsZero() 方法，通过这个方法就可以判断 v 值是否为 0，例如：

if  v.IsZero() {// v等于0
}

为基本类型添加方法的详细实现流程如下：

package main
import ("fmt"
)
// 将int定义为MyInt类型
type MyInt int
// 为MyInt添加IsZero()方法
func (m MyInt) IsZero() bool {return m == 0
}
// 为MyInt添加Add()方法
func (m MyInt) Add(other int) int {return other + int(m)
}
func main() {var b MyIntfmt.Println(b.IsZero())b = 1fmt.Println(b.Add(2))
}

4 接口

在Go语言中接口（interface）是一种类型，一种抽象的类型。

interface是一组method的集合，接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。

接口（interface）是一种类型

接口类型是对其它类型行为的抽象和概括；因为接口类型不会和特定的实现细节绑定在一起，通过这种抽象的方式我们可以让我们的函数更加灵活和更具有适应能力。

接口是双方约定的一种合作协议。接口实现者不需要关心接口会被怎样使用，调用者也不需要关心接口的实现细节。接口是一种类型，也是一种抽象结构，不会暴露所含数据的格式、类型及结构。

4.1 为什么要使用接口

type Cat struct{}func (c Cat) Say() string { return "喵喵喵" }type Dog struct{}func (d Dog) Say() string { return "汪汪汪" }func main() {c := Cat{}fmt.Println("猫:", c.Say())d := Dog{}fmt.Println("狗:", d.Say())
}

上面的代码中定义了猫和狗，然后它们都会叫，你会发现main函数中明显有重复的代码，如果我们后续再加上猪、青蛙等动物的话，我们的代码还会一直重复下去。那我们能不能把它们当成“能叫的动物”来处理呢？

像类似的例子在我们编程过程中会经常遇到：

比如一个网上商城可能使用支付宝、微信、银联等方式去在线支付，我们能不能把它们当成“支付方式”来处理呢？

比如三角形，四边形，圆形都能计算周长和面积，我们能不能把它们当成“图形”来处理呢？

比如销售、行政、程序员都能计算月薪，我们能不能把他们当成“员工”来处理呢？

Go语言中为了解决类似上面的问题，就设计了接口这个概念。接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

4.2 接口定义

Go语言提倡面向接口编程。

每个接口类型由数个方法组成。接口的形式代码如下：

type 接口类型名 interface{方法名1( 参数列表1 ) 返回值列表1方法名2( 参数列表2 ) 返回值列表2…
}

对各个部分的说明：

• 接口类型名：使用 type 将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加 er，如有写操作的接口叫 Writer，有字符串功能的接口叫 Stringer，有关闭功能的接口叫 Closer 等。
• 方法名：当方法名首字母是大写时，且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
• 参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以被忽略

type Writer interface{//大写字母开头 意味着别的包 也可以访问Write([]byte) error
}

4.3 接口实现条件

如果一个任意类型 T 的方法集为一个接口类型的方法集的超集，则我们说类型 T 实现了此接口类型。

T 可以是一个非接口类型，也可以是一个接口类型。

实现关系在Go语言中是隐式的。两个类型之间的实现关系不需要在代码中显式地表示出来。Go语言中没有类似于 implements 的关键字。 Go编译器将自动在需要的时候检查两个类型之间的实现关系。

接口定义后，需要实现接口，调用方才能正确编译通过并使用接口。

接口的实现需要遵循两条规则才能让接口可用：

1. 接口的方法与实现接口的类型方法格式一致

   在类型中添加与接口签名一致的方法就可以实现该方法。

   签名包括方法中的名称、参数列表、返回参数列表。

   也就是说，只要实现接口类型中的方法的名称、参数列表、返回参数列表中的任意一项与接口要实现的方法不一致，那么接口的这个方法就不会被实现。

   示例：

   package main
   import ("fmt"
   )
   // 定义一个数据写入器
   type DataWriter interface {WriteData(data interface{}) error
   }
   // 定义文件结构，用于实现DataWriter
   type file struct {
   }
   // 实现DataWriter接口的WriteData方法
   func (d *file) WriteData(data interface{}) error {// 模拟写入数据fmt.Println("WriteData:", data)return nil
   }
   func main() {// 实例化filef := new(file)// 声明一个DataWriter的接口var writer DataWriter// 将接口赋值f，也就是*file类型writer = f// 使用DataWriter接口进行数据写入writer.WriteData("data")
   }
   

   在 Go 中，interface{} 是一种空接口类型，表示可以接受任何类型的值。当你传入一个 string 类型的值（如 "data"）时，它实际上是传入了一个具体类型的值，但是 Go 的空接口 (interface{}) 允许你传入任何类型的值。

   当类型无法实现接口时，编译器会报错：

   1. 函数名不一致导致的报错
   2. 实现接口的方法签名不一致导致的报错

2. 接口中所有方法均被实现

   当一个接口中有多个方法时，只有这些方法都被实现了，接口才能被正确编译并使用。

   // 定义一个数据写入器
   type DataWriter interface {WriteData(data interface{}) error// 新增一个方法 能否写入CanWrite() bool
   }
   

   在此运行上述的程序，就会报错：

   cannot use f (type *file) as type DataWriter in assignment:*file does not implement DataWriter (missing CanWrite method)
   

   需要在 file 中实现 CanWrite() 方法才能正常使用 DataWriter()。

   Go语言的接口实现是隐式的，无须让实现接口的类型写出实现了哪些接口。

   这个设计被称为非侵入式设计。

4.4 类型与接口的关系

在Go语言中类型和接口之间有一对多和多对一的关系

一个类型可以实现多个接口

一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。

例如，狗可以叫，也可以动。

我们就分别定义Sayer接口和Mover接口，如下：

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}

dog既可以实现Sayer接口，也可以实现Mover接口。

type dog struct {name string
}// 实现Sayer接口
func (d dog) say() {fmt.Printf("%s会叫汪汪汪\n", d.name)
}// 实现Mover接口
func (d dog) move() {fmt.Printf("%s会动\n", d.name)
}func main() {var x Sayervar y Movervar a = dog{name: "旺财"}x = ay = ax.say()y.move()
}

多个类型实现同一接口

Go语言中不同的类型还可以实现同一接口 首先我们定义一个Mover接口，它要求必须有一个move方法。

// Mover 接口
type Mover interface {move()
}

例如狗可以动，汽车也可以动，可以使用如下代码实现这个关系：

type dog struct {name string
}type car struct {brand string
}// dog类型实现Mover接口
func (d dog) move() {fmt.Printf("%s会跑\n", d.name)
}// car类型实现Mover接口
func (c car) move() {fmt.Printf("%s速度70迈\n", c.brand)
}

这个时候我们在代码中就可以把狗和汽车当成一个会动的物体来处理了，不再需要关注它们具体是什么，只需要调用它们的move方法就可以了。

func main() {var x Movervar a = dog{name: "旺财"}var b = car{brand: "保时捷"}x = ax.move()x = bx.move()
}

并且一个接口的方法，不一定需要由一个类型完全实现，接口的方法可以通过在类型中嵌入其他类型或者结构体来实现。

// WashingMachine 洗衣机
type WashingMachine interface {wash()dry()
}// 甩干器
type dryer struct{}// 实现WashingMachine接口的dry()方法
func (d dryer) dry() {fmt.Println("甩一甩")
}// 海尔洗衣机
type haier struct {dryer //嵌入甩干器
}// 实现WashingMachine接口的wash()方法
func (h haier) wash() {fmt.Println("洗刷刷")
}

接口嵌套

接口与接口间可以通过嵌套创造出新的接口

// Sayer 接口
type Sayer interface {say()
}// Mover 接口
type Mover interface {move()
}// 接口嵌套
type animal interface {SayerMover
}

嵌套得到的接口的使用与普通接口一样，这里我们让cat实现animal接口：

type cat struct {name string
}func (c cat) say() {fmt.Println("喵喵喵")
}func (c cat) move() {fmt.Println("猫会动")
}func main() {var x animalx = cat{name: "花花"}x.move()x.say()
}

4.5 空接口

空接口是指没有定义任何方法的接口。

因此任何类型都实现了空接口。

空接口类型的变量可以存储任意类型的变量。

func main() {// 定义一个空接口xvar x interface{}s := "go教程"x = sfmt.Printf("type:%T value:%v\n", x, x)i := 100x = ifmt.Printf("type:%T value:%v\n", x, x)b := truex = bfmt.Printf("type:%T value:%v\n", x, x)
}

4.5.1 空接口的应用

空接口作为函数的参数

使用空接口实现可以接收任意类型的函数参数。

// 空接口作为函数参数
func show(a interface{}) {fmt.Printf("type:%T value:%v\n", a, a)
}

空接口作为map的值

使用空接口实现可以保存任意值的字典。

// 空接口作为map值var studentInfo = make(map[string]interface{})studentInfo["name"] = "李白"studentInfo["age"] = 18studentInfo["married"] = falsefmt.Println(studentInfo)

4.5.2 类型断言

空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？

接口值

一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。

这两部分分别称为接口的动态类型和动态值。

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：

x.(T)

其中：

1. x：表示类型为interface{}的变量

2. T：表示断言x可能是的类型。

该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。

func main() {var x interface{}x = "go教程"v, ok := x.(string)if ok {fmt.Println(v)} else {fmt.Println("类型断言失败")}
}

上面的示例中如果要断言多次就需要写多个if判断，这个时候我们可以使用switch语句来实现：

func justifyType(x interface{}) {switch v := x.(type) {case string:fmt.Printf("x is a string，value is %v\n", v)case int:fmt.Printf("x is a int is %v\n", v)case bool:fmt.Printf("x is a bool is %v\n", v)default:fmt.Println("unsupport type！")}
}

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。

关于接口需要注意的是，只有当有两个或两个以上的具体类型必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。

5 I/O操作

I/O操作也叫输入输出操作。其中I是指Input，O是指Output，用于读或者写数据的，有些语言中也叫流操作，是指数据通信的通道。

Golang 标准库对 IO 的抽象非常精巧，各个组件可以随意组合，可以作为接口设计的典范。

io包中提供I/O原始操作的一系列接口。

它主要包装了一些已有的实现，如 os 包中的那些，并将这些抽象成为实用性的功能和一些其他相关的接口。

由于这些接口和原始的操作以不同的实现包装了低级操作，客户不应假定它们对于并行执行是安全的。

io库比较常用的接口有三个，分别是Reader，Writer和Closer。

5.1 Reader

Reader接口的定义，Read()方法用于读取数据。

type Reader interface {Read(p []byte) (n int, err error)
}

io.Reader 表示一个读取器，它将数据从某个资源读取到传输缓冲区。在缓冲区中，数据可以被流式传输和使用。

• 对于要用作读取器的类型，它必须实现 io.Reader 接口的唯一一个方法 Read(p []byte)。
• 换句话说，只要实现了 Read(p []byte) ，那它就是一个读取器。
• Read() 方法有两个返回值，一个是读取到的字节数，一个是发生错误时的错误。

通过 string.NewReader(string) 创建一个字符串读取器，然后流式地按字节读取：

package mainimport ("io""log""os""strings"
)func main() {reader := strings.NewReader("zhangsan test123 123")// 每次读取4个字节p := make([]byte, 4)for {n, err := reader.Read(p)if err != nil {if err == io.EOF {log.Printf("读完了:eof错误 :%d", n)break}log.Printf("其他错误:%v", err)os.Exit(2)}log.Printf("[读取到的字节数为:%d][内容:%v]", n, string(p[:n]))}}

 [读取到的字节数为:4][内容:mszl][读取到的字节数为:4][内容:u te][读取到的字节数为:4][内容:st12][读取到的字节数为:4][内容:3 12][读取到的字节数为:1][内容:3]读完了:eof错误 :0

• 最后一次返回的 n 值有可能小于缓冲区大小。
• io.EOF 来表示输入流已经读取到头

strings.Reader.Read方法:

func (r *Reader) Read(b []byte) (n int, err error) {if r.i >= int64(len(r.s)) {return 0, io.EOF}r.prevRune = -1n = copy(b, r.s[r.i:])r.i += int64(n)return
}

5.1.1 文件操作相关API

• func Create(name string) (file *File, err Error)
  

  • 根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666

• func NewFile(fd uintptr, name string) *File
  

  • 根据文件描述符创建相应的文件，返回一个文件对象

• func Open(name string) (file *File, err Error)
  

  • 只读方式打开一个名称为name的文件

• func OpenFile(name string, flag int, perm uint32) (file *File, err Error)
  

  • 打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限

• func (file *File) Write(b []byte) (n int, err Error)
  

  • 写入byte类型的信息到文件

• func (file *File) WriteAt(b []byte, off int64) (n int, err Error)
  

  • 在指定位置开始写入byte类型的信息

• func (file *File) WriteString(s string) (ret int, err Error)
  

  • 写入string信息到文件

• func (file *File) Read(b []byte) (n int, err Error)
  

  • 读取数据到b中

• func (file *File) ReadAt(b []byte, off int64) (n int, err Error)
  

  • 从off开始读取数据到b中

• func Remove(name string) Error
  

  • 删除文件名为name的文件

5.1.2 读文件

type Closer interface {Close() error
}

os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用Close()方法能够关闭文件。

文件读取可以用file.Read()，读到文件末尾会返回io.EOF的错误

package mainimport ("fmt""io""os"
)func main() {// 打开文件file, err := os.Open("./xxx.txt")if err != nil {fmt.Println("open file err :", err)return}defer file.Close()// 定义接收文件读取的字节数组var buf [128]bytevar content []bytefor {n, err := file.Read(buf[:])if err == io.EOF {// 读取结束break}if err != nil {fmt.Println("read file err ", err)return}content = append(content, buf[:n]...)}fmt.Println(string(content))
}

5.2 Writer

type Writer interface {//Write() 方法有两个返回值，一个是写入到目标资源的字节数，一个是发生错误时的错误。Write(p []byte) (n int, err error)
}

• io.Writer 表示一个写入器，它从缓冲区读取数据，并将数据写入目标资源。
• 对于要用作编写器的类型，必须实现 io.Writer 接口的唯一一个方法 Write(p []byte)
• 同样，只要实现了 Write(p []byte) ，那它就是一个编写器。

写文件：

package mainimport ("fmt""os"
)func main() {// 新建文件file, err := os.Create("./test.txt")if err != nil {fmt.Println(err)return}defer file.Close()for i := 0; i < 5; i++ {file.WriteString("ab\n")file.Write([]byte("cd\n"))}
}

5.3 bufio

• bufio包实现了带缓冲区的读写，是对文件读写的封装
• bufio缓冲写数据

模式	含义
os.O_WRONLY	只写
os.O_CREATE	创建文件
os.O_RDONLY	只读
os.O_RDWR	读写
os.O_TRUNC	清空
os.O_APPEND	追加

bufio读写数据

package mainimport ("bufio""fmt""io""os"
)func wr() {// 参数2：打开模式，所有模式d都在上面// 参数3是权限控制// w写 r读 x执行   w  2   r  4   x  1//特殊权限位，拥有者位，同组用户位，其余用户位file, err := os.OpenFile("./xxx.txt", os.O_CREATE|os.O_WRONLY, 0666)if err != nil {return}defer file.Close()// 获取writer对象writer := bufio.NewWriter(file)for i := 0; i < 10; i++ {writer.WriteString("hello\n")}// 刷新缓冲区，强制写出writer.Flush()
}func re() {file, err := os.Open("./xxx.txt")if err != nil {return}defer file.Close()reader := bufio.NewReader(file)for {line, _, err := reader.ReadLine()if err == io.EOF {break}if err != nil {return}fmt.Println(string(line))}}func main() {re()
}

5.4 ioutil工具包

• ioutil库包含在io目录下，它的主要作用是作为一个工具包，里面有一些比较实用的函数
• 比如 ReadAll(从某个源读取数据)、ReadFile（读取文件内容）、WriteFile（将数据写入文件）、ReadDir（获取目录）

package mainimport ("fmt""io/ioutil"
)func wr() {err := ioutil.WriteFile("./yyy.txt", []byte("go教程"), 0666)if err != nil {fmt.Println(err)return}
}func re() {content, err := ioutil.ReadFile("./yyy.txt")if err != nil {fmt.Println(err)return}fmt.Println(string(content))
}func main() {re()
}

5.5 实现一个cat命令

使用文件操作相关知识，模拟实现linux平台cat命令的功能。

package mainimport ("bufio""flag""fmt""io""os"
)// cat命令实现
func cat(r *bufio.Reader) {for {buf, err := r.ReadBytes('\n') //注意是字符if err == io.EOF {break}fmt.Fprintf(os.Stdout, "%s", buf)}
}func main() {flag.Parse() // 解析命令行参数if flag.NArg() == 0 {// 如果没有参数默认从标准输入读取内容cat(bufio.NewReader(os.Stdin))}// 依次读取每个指定文件的内容并打印到终端for i := 0; i < flag.NArg(); i++ {f, err := os.Open(flag.Arg(i))if err != nil {fmt.Fprintf(os.Stdout, "reading from %s failed, err:%v\n", flag.Arg(i), err)continue}cat(bufio.NewReader(f))}
}