Go语言学习笔记（三）

十一、结构体

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

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

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

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

结构体的定义格式如下：

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

• 类型名：标识自定义结构体的名称，在同一个包内不能重复。
• struct{}：表示结构体类型，type 类型名 struct{}可以理解为将 struct{} 结构体定义为类型名的类型。
• 字段1、字段2……：表示结构体字段名，结构体中的字段名必须唯一。
• 字段1类型、字段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   int
	data string
}) {
	// 使用动词%T打印msg的类型
	fmt.Printf("%T\n, msg:%v", msg,msg)
}
func main() {
	// 实例化一个匿名结构体
	msg := &struct {  // 定义部分
		id   int
		data string
	}{  // 值初始化部分
		1024,
		"hello",
	}
	printMsgType(msg)
}

匿名字段

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

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

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

package main

import "fmt"

type User struct {
    id   int
    name 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 main

import "fmt"

type User struct {
    id   int
    name string
}

type Manager struct {
    User
    title 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())
}

十二、方法

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

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

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

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

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

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

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

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

为结构体添加方法：

需求：将物品放入背包

面向对象的写法：

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

package main

import "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 作用的对象实例。每个方法只能有一个接收器

接收器

接收器的格式如下：

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 int
    Y 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)
}

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

十三、接口

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

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

接口（interface）是一种类型

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

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

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

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

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

对各个部分的说明：

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

接口实现条件

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

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

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

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

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

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

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

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

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

   **当类型无法实现接口时，编译器会报错：**函数名不一致导致的报错、实现接口的方法签名不一致导致的报错

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

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

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

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

空接口

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

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

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

空接口作为函数的参数

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

// 空接口作为函数参数
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"] = 18
    studentInfo["married"] = false
    fmt.Println(studentInfo)

类型断言

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

接口值

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

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

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

x.(T)

其中：

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

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

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

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

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

十四、IO操作

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

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

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

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

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

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

Reader

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

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

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

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

文件操作相关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的文件

Writer

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

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

bufio

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

ioutil工具包

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

综合示例

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

package main

import (
    "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))
    }
}

十五、包和go mod

包

Go语言是使用包来组织源代码的，包（package）是多个 Go 源码的集合，是一种高级的代码复用方案。Go语言中为我们提供了很多内置包，如 fmt、os、io 等。

任何源代码文件必须属于某个包，同时源码文件的第一行有效代码必须是package pacakgeName 语句，通过该语句声明自己所在的包。

Go语言的包借助了目录树的组织形式，一般包的名称就是其源文件所在目录的名称，虽然Go语言没有强制要求包名必须和其所在的目录名同名，但还是建议包名和所在目录同名，这样结构更清晰。

包可以定义在很深的目录中，包名的定义是不包括目录路径的，但是包在引用时一般使用全路径引用。

包的习惯用法：

• 包名一般是小写的，使用一个简短且有意义的名称。
• 包名一般要和所在的目录同名，也可以不同，包名中不能包含- 等特殊符号。
• 包名为 main 的包为应用程序的入口包，编译不包含 main 包的源码文件时不会得到可执行文件。
• 一个文件夹下的所有源码文件只能属于同一个包，同样属于同一个包的源码文件不能放在多个文件夹下。

包的绝对路径就是GOROOT/src/或GOPATH后面包的存放路径，如下所示：

import "lab/test"
import "database/sql/driver"
import "database/sql"

上面代码的含义如下：

• test 包是自定义的包，其源码位于GOPATH/lab/test 目录下；
• driver 包的源码位于GOROOT/src/database/sql/driver 目录下；
• sql 包的源码位于GOROOT/src/database/sql 目录下。

包的引用格式

• 标准引用格式

import "fmt"

此时可以用fmt.作为前缀来使用 fmt 包中的方法，这是常用的一种方式。

• 自定义别名引用格式

在导入包的时候，我们还可以为导入的包设置别名，如下所示：

import F "fmt"

其中 F 就是 fmt 包的别名，使用时我们可以使用F.来代替标准引用格式的fmt.来作为前缀使用 fmt 包中的方法

• 省略引用格式

import . "fmt"

这种格式相当于把 fmt 包直接合并到当前程序中，在使用 fmt 包内的方法是可以不用加前缀fmt.，直接引用。

• 匿名引用格式

在引用某个包时，如果只是希望执行包初始化的 init 函数，而不使用包内部的数据时，可以使用匿名引用格式，如下所示：

import _ "fmt"

匿名导入的包与其他方式导入的包一样都会被编译到可执行文件中。

go mod

go module 是Go语言从 1.11 版本之后官方推出的版本管理工具，并且从 Go1.13 版本开始，go module 成为了Go语言默认的依赖管理工具。

Modules 官方定义为：

Modules 是相关 Go 包的集合，是源代码交换和版本控制的单元。Go语言命令直接支持使用 Modules，包括记录和解析对其他模块的依赖性，Modules 替换旧的基于 GOPATH 的方法，来指定使用哪些源文件。

使用go module之前需要设置环境变量：

1. GO111MODULE=on
2. GOPROXY=https://goproxy.io,direct
3. GOPROXY=https://goproxy.cn,direct(国内的七牛云提供)

GO111MODULE 有三个值：off, on和auto（默认值）。

• GO111MODULE=off，go命令行将不会支持module功能，寻找依赖包的方式将会沿用旧版本那种通过vendor目录或者GOPATH模式来查找。
• GO111MODULE=on，go命令行会使用modules，而一点也不会去GOPATH目录下查找。
• GO111MODULE=auto，默认值，go命令行将会根据当前目录来决定是否启用module功能。这种情况下可以分为两种情形：
  • 当前目录在GOPATH之外且该目录包含go.mod文件 开启
  • 当处于 GOPATH 内且没有 go.mod 文件存在时其行为会等同于 GO111MODULE=off
• 如果不使用 Go Modules, go get 将会从模块代码的 master 分支拉取
• 而若使用 Go Modules 则你可以利用 Git Tag 手动选择一个特定版本的模块代码

go mod 有以下命令：

• 常用的有 init tdiy edit

使用go get命令下载指定版本的依赖包：

执行go get 命令，在下载依赖包的同时还可以指定依赖包的版本。

• 运行go get -u命令会将项目中的包升级到最新的次要版本或者修订版本；
• 运行go get -u=patch命令会将项目中的包升级到最新的修订版本；
• 运行go get [包名]@[版本号]命令会下载对应包的指定版本或者将对应包升级到指定的版本。

提示：go get [包名]@[版本号]命令中版本号可以是 x.y.z 的形式，例如 go get foo@v1.2.3，也可以是 git 上的分支或 tag，例如 go get foo@master，还可以是 git 提交时的哈希值，例如 go get foo@e3702bed2。

go.mod 文件一旦创建后，它的内容将会被 go toolchain 全面掌控，go toolchain 会在各类命令执行时，比如go get、go build、go mod等修改和维护 go.mod 文件。

go.mod 提供了 module、require、replace 和 exclude 四个命令：

• module 语句指定包的名字（路径）；
• require 语句指定的依赖项模块；
• replace 语句可以替换依赖项模块；
• exclude 语句可以忽略依赖项模块。

go module 安装 package 的原则是先拉取最新的 release tag，若无 tag 则拉取最新的 commit

go 会自动生成一个 go.sum 文件来记录 dependency tree。

执行脚本go run main.go，就可以运行项目。

可以使用命令go list -m -u all来检查可以升级的 package，使用go get -u need-upgrade-package升级后会将新的依赖版本更新到 go.mod ，

比如：go get -u github.com/labstack/gommon

也可以使用go get -u升级所有依赖。

使用 replace 替换无法直接获取的 package：

由于某些已知的原因，并不是所有的 package 都能成功下载，比如：golang.org 下的包。

modules 可以通过在 go.mod 文件中使用 replace 指令替换成 github 上对应的库，比如：

replace (
    golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a => github.com/golang/crypto v0.0.0-20190313024323-a1f597ede03a
)

或者

replace golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a => github.com/golang/crypto v0.0.0-20190313024323-a1f597ede03a

go install命令将项目打包安装为可执行文件，在安装在GOPATH的bin目录下，go install执行的项目 必须有main方法