# GoLang 学习笔记

# 1.Go(package)

# 1. 标准库概述

• 像 fmt, os 等具有常用功能的内置包被称为标准库，大部分内置于 Go 本身

• unsafe : 包含一些打破 GO 语言 "类型安全" 的命令，一般程序中不回使用，可用在 C/C++ 程序的调用中

• syscall - os - os/exec :

  • os : 提供平台无关性的擦偶作系统功能接口，采用 Unix 设计，隐藏了不同操作系统间的差异，让不

    同的文件系统和操作系统对象表现一致

  • os/exec : 提供运行外部操作系统命令和程序的方式

  • syscall : 底层的外部包，提供操作系统底层调用的基本接口

• archive/tar 和 /zip-commpress : 压缩 (解压缩) 文件

• fmt - io - bufio - path/filepath - flag :

  • fmt : 提供格式化输入输出功能.
  • io : 提供了基本输入输出功能，大多数是围绕系统功能的封装
  • bufio : 缓冲输入输出功能的封装
  • path/filepath : 用来操作当前系统中的目标文件名路径
  • flag : 对命令行参数的操作

• strings - strconv - unicode - regexp - bytes :

  • strings : 提供对字符串的操作
  • strconv : 提供将字符串转为基础类型的功能
  • unicode : 为 Unicode 类型的字符串提供特殊的功能
  • regexp : 正则表达式功能
  • bytes : 提供对字符串分片的操作
  • index/suffixarray : 字符串快速查询

• math - math/cmath - math/big - math/rand - sort:

  • math : 基本数学函数
  • math/cmath : 对复数的操作
  • math/rand : 伪随机数生成
  • sort : 数组，自定义集合排序
  • math/big : 大数字的实现和计算

• container - /list-ring-heap : 集合操作

  • list : 双链表
  • right : 环形链表

• time - log

  • time : 日期和时间的基本操作.
  • log : 记录程序运行时产生的日志

• encoding/json - encoding/xml - text/template :

  • encoding/json : 读取并解码 写入并编码 JSON 数据
  • encoding/xml : 简单的 XML1.0 解析器
  • text/template : 生成像 HTML 一样的数据与文本混合的驱动模板

• net - net/http - html :

  • net : 网络数据的基本操作
  • http : 提供一个可拓展的 HTTP 服务器和基础客户端，解析 HTTP 请求和回复
  • html : HTML5 解析器

• runtime : Go 程序运行时的交互操作，例如垃圾回收和携程创建

• reflect : 实现通过程序运行时反射，让程序操作任意类型的变量

• exp : 包中有许多将被编译为新包的实验性包.

# 2.regexp 包

• 简单模式，使用 Match 方法，变量 ok 将返回 true 或者 false

  ok, _ := regexp.Match(pat,[]byte(searchIn))

• 使用 MatchString , 直接传入字符串

  ok, _ := regexp.MatchString(pat, searchIn)

• Compile 函数肯返回一个错误，一般使用时忽略对错误的判断，

• NustCompile 一样可以检验正则的有效性，当正则不合法时，程序将 panic

# 3. 锁和 sync 包

• 复杂程序中，通常通过不同线程执行不同应用来实现程序的并发，导致不同线程对同一变量

  使用的竞争 (通常被称为资源竞争)

• map 类型不存在锁机制来实现安全访问的效果 (出于对性能的考虑),map 类型是非线程安全的，

  并行访问共享的 map 类型数据时，map 数据将会出错

• Go 语言的锁机制时通过 sync 包中的 Mutex 来实现的，sync 来源于 synchronize, 表示线程

  将有序的对同一变量进行访问

• sync.Mutex 是一个互斥锁，其作用是守护领截取入口，确保同一时间只能有一个线程进入

  临界区

• sync 包中还有 RWMutex 锁：通过 RLock() 允许同一时间多个线程对变量进行读操作，但只能

  一个线程进行写操作，如果使用 Lock() 将和普通的 Mutex 作用相同， 包中还有 once.Do(call)

  这个方法确保被调用函数只能被调用一次

• sync 可以解决同一时间只能一个线程访问 map 类型数据的问题，但会导致程序明显变慢或引起其他

  问题，go 提倡使用 goroutines 和 channels 来解决问题

import "sync"

type Infostruct{

    mu sync.Mutex

    //···other fields,s1.s2.: Str string

}

func Update(info *Info){

    info.mu.Lock()

    info.Str = //new value

    info.mu.Unlock()

}

# 4. 精密计算和 big 包

• go 语言中的 float64 类型进行浮点运算，返回结果精确到 15 位，但对超出 int64 或 uint64 类型的

  大数字进行计算时对精度要求严格，就无法使用浮点数，在内存中只能近似的表示

• 对于整数的高精度计算 GO 语言提供了 big 包，包含在 math 包下，有用来表示大有理数的 big.Rat 类型

  和表示大整数的 big.Int 类型，可以实现任意类型的数字，但内存消耗更大，处理起来也比内置的数字类型

  慢很多

• 大整型数字是通过 big.NewInt(n) 来构造的，n 为 int64 类型整数.

• 大有理数通过 big.NewRat(n,d) 构造， n(分子) d(分母) 都是 int64 类型整数

• 大数字类型计算，Add (),Sub (),Mul (),Div () < 加，减，乘，除 >, 计算结果返回后可链式调用，无需中

  间变量保存，节省内存

# 5. 自定义包和可见性

• 包时 Go 语言中代码组织和代码编译的主要方式.

• 自定义包命名要使用短小且不含有 _(下划线) 的小写单词来为文件命名

• import alias "./pack" 导入 pack 包，并取别名 alias , 通过 alias 进行调用

• import . "./pack" 使用 . 作为包的别名时，可以不通过包名来使用其中的项目

  例如: test := ReturnStr()

• import _ "./pack1/pack1" , 只导入其副作用，只执行它的 init 函数并初始化其中的全局变量

• 导入外部安装包 go install

• go mod 使用时包引用需要以项目根路径开始

# 2. 结构体 (struct)

• Go 通过类型别名 (alias types) 和 结构体的形式支持用户自定义类型，一个带属性的结构体试图表示显示世界中的实体。结构体是复合类型 (composite types), 当需要定义一个类型，由一系列属性组成，就应该使用结构体，结构体将数据聚集在一起进行访问，就像是一个独立实体的一部分，结构体也是值类型，因此可以通过 new 函数来创建.
• 组成结构体类型的数据被称为字段，每个字段都有一个类型和名字，在结构体中， 字段名字必须是唯一的
• 结构体在软件工程上旧的术语是 ADT (抽象数据类型 Abstract Data Type), 在一些老的编程语言中称为记录 (Record), 在 c 家族中也存在，并且也是 struct, 在面向对象的变成语言中，类似于无方法的轻量级类，但 Go 语言没有类的概念，因此，Go 中结构体有着更为重要的地位.
• 结构体是值类型数据

# 1. 结构体定义

• 结构体定义的一般方式

type identifier struct {

    field1 type1

    field2 type2

    ...

}

// 定义简单的结构体

typr T struct {a,b int}

• 结构体的字段都有名字，如果字段在代码中从来不会被使用，那么也可以命名为 _(下划线).
• 结构体的字段可以是任何类型，甚至可以是结构体本身，也可以是函数或结构
• 数组可以看作是一种结构体类型，不过其使用的是下标不是具名的字段
• new 函数给一个新的结构体分配内存，返回指向已分配内存的指针: var t *T = new(T) , 如果需要可以将语句放在不同的行 (例如：定义是包范围的，但是却没必要立刻分配)

var t *T

t = new(T)

// 惯用语法，变量 t 是指向 T 的指针，此时结构体字段值为所属类型的零值

t := new(T)

/**

* 声明 t 也会给 t 分配内存，并零值化内存，但此时 t 是类型 T,

* 在这两种方式中 t 被称为 类型 T 的 一个实例 (instance) 或 对象 (object)

*/

var t T

• 使用 fmt.Println 打印一个结构体的默认输出可以很好的显示其内容，类似使用 % v 选项

• 像面向对象的语言那样，结构体也可以使用点号符给字段赋值: structname.fieldname = value

• 使用点号符可以获取结构体的字段值: structname.filedname , 在 Go 语言中这叫做 ** 选择器 (selector)** 无论是 结构体类型 还是结构体类型指针，都使用同样的 ** 选择器符 (selector-notation)** 来引用结构体的字段

typr myStruct struct {i int}

var v myStruct //v 是结构体类型变量

var p *myStruct //p 是指向一个结构体类型变量的指针

v.i

p.i

// 初始化结构体实例的 更简短和惯用的方式如下:

ms := &struct1{10, 15.6, "Chris"}

// 混合字面量语法 (composite literal syntax) &struct {a, b, c} 是一种简写，底层仍会调用 new ()

• 初始化结构体实例的 更简短和惯用的方式如下: ms := &struct1{10, 15.6, "Chris"}

• 混合字面量语法 (composite literal syntax) &struct{a, b, c} 是一种简写，

  底层仍会调用 new() , 这里的值必须按照字段顺序来写，表达式 new(Type) 和 &Type{} 是等价的

• 结构体的初始化方式

• (A): 必须以字段在结构体定义时的顺序赋值，& 不是必须的

• (B): fieldname (字段名) : val (值), 这种形式顺序不必一直

• (C): fieldname : val 形式赋值可以进行部分赋值

typr Interval struct {

    start int

    end int

}

// 初始化方式

方式(A):	intr := Interval{0 ,3}

方式(B):	intr := Interval{end: 5,start: 1}

方式(C):	intr := Interval{end: 5}

结构体初始化

• 结构体声明时，其值类型字段默认为相关类型的空值
• 其引用数据类型默认为 nil, 使用 slice, map 等引用类型时，需要先 make 再使用
• 不同结构体字段时独立的，互不影响

使用 new 初始化

作为结构体字面量初始化

struct 初始化及调用的不同方式

type Personstruct {

    firstName string

    lastName string

}

func upPerson(p *Person) {

    p.firstName = strings.ToUpper(p.firstName)

    p.lastName = strings.ToUpper(p.lastName)

}

func main() {

// 1-struct as a value type:

var pers1 Person

    pers1.firstName = "Chris"

    Pers1.lastName = "Woodward"

    upPerson(&pers1)

    fmt.Printf("The name of the person is %s %s\n",pers1.firstName,pers1.lastName)

// 2-struct as a pointer

    pers2 := new(Person)

   	/**

   	* 通过 new 出来的指针，也可以直接使用 

   	* . 点语法进行字段赋值

   	* GO 语言会自动进行转换

   	*/

    pers2.firstName = "Chris"

    pers2.lastName = "Woodward"

    // 通过解指针的方式来设置值

    (*pers2).lastName = "Woodward"

    upPerson(pers2)

    fmt.Printf("The name of the person is %s %s\n",pers1.firstName,pers1.lastName)

// 3-struct as a literal:

    pers3 := &Person{"Chris","Woodward"}    

    upPerson(per3)

    fmt.Printf("The name of the person is %s %s\n",pers1.firstName,pers1.lastName)

// 4-struct as a literal:

    pers3 := &Person{firstName: "Chris",lastName: "Woodward"}    

    upPerson(per3)

    fmt.Printf("The name of the person is %s %s\n",pers1.firstName,pers1.lastName)

}

结构体的内存布局

Go 语言中，结构体和其所包含的数据类型在内存中是以连续块的形式存在的，(即使结构体中嵌套有其他的结构体)

type Rect1struct{Min,MaxPoint}

type Rect2struct{Min,Max*Point}

递归结构体：链表

/**

* 链表的第一个元素为 head, 其指向第二个元素，

* 最后一个元素 tail 没有后继元素，所以 su 为 nil

* 链表存在很多数据节点，且可以动态增长或收缩

*/

type Nodestruct{

    data    float64

    su      *Node

}

// 双向链表，由前趋节点 pr 和 后继节点 su :

type Nodestruct{

    pr      *Node

    data    float64

    su      *Node

}

递归结构体：二叉树

/**

* 二叉树每个节点 至多链接至两个节点: 

* 左节点 (le) 右节点 (ri)

* 左右节点本身也可以有左右节点

* 树的顶层节点：根节点 (root)		

* 叶子节点 (leaves), 叶子节点的 le 和 ri 指针为 nil

*/

type Treestruct {

	le *Tree

    data float64

    ri *Tree

}

结构体转换

Go 类型转换遵循严格的规则，当结构体定义了一个 alias (别名) 类型时，结构体 和 其 alias 类型都有相同的底层类型，两者可以互相转换，但须注意其中非法复制或转换引起的编译错误

type number struct {

    f float32

}

type nr number	//alias type

func main() {

    a := number{5.0}

    b := nr{5.0}

    // var i float32 = b   

    // compile-error: cannot use b (type nr) as type float32 in assignment

	// var i = float32(b)  

    // compile-error: cannot convert b (type nr) to type float32

	// var c number = b    

    // compile-error: cannot use b (type nr) as type number in assignment

	// needs a conversion:

	var c = number(b)

    fmt.Println(a, b, c)

}

# 2. 结构体工厂

• Go 语言不支持面向对象编程语言中的构造方法，但可以很容易的在 Go 中实现 =="构造工厂"== 方法.

​ 通常会为类型定义一个工厂，工厂名字以 new 或 New 开头

type File struct {

    fd int	// 文件描述符

    name string	// 文件名

}

// 结构体类型对应的工厂方法，返回一个指向结构体实例的指针

func NewFile(fd int, name string) *File {

    if fd < 0 {

        return nil

    } 

    return &File{fd, name}

}

// 调用工厂方法，返回实例化对象

f := NewFile(10,"./test.txt")

• 结构体类型 初始化表达式 new(File) 和 &File{} 是等价的
• 获取 结构体类型 T 的一个实例占用内存，size := unsafe.Sizeof (T {})
• 强制使用工厂方法：结构体名称首字母小写变为私有

type matrix struct {

    ...

}

func NewMatrix(params) *matrix {

    m := new(matrix) // 初始化 m

    return m

}

// 在其他包中使用工厂

package main

import "matrix"

...

wrong := new(matrix.matrix)     // 编译失败（matrix 是私有的）

right := matrix.NewMatrix(...)  // 实例化 matrix 的唯一方式

• map 和 struct vs new () 和 make ()

• 能够使用 make() 的三种类型 : slice\maps\channels

• make() 一个结构体变量，会 引发编译错误

• new() 一个 map 向其填充数据会 引发运行时错误 ， new(slice) 返回的是 指向nil的指针

  其尚未被分配内存，所以在使用 map 是需要谨慎

# 3. 使用自定义包的结构体

在 main.go 中使用来自 struct_pack 下的包 structPack

// structPack.go

package structPack

type ExpStruct struct {

    Mi1	int

    Mf1	int

}

// main.go

package main

import (

	"fmt"

    "./struct/pack/structpack"

)

func main() {

    struct := new(structPack.ExpStruct)

    struct.Mi1 = 10

    struct.Mf1 = 16

    fmt.Printf("Mi1 = %d\n", struct1.Mi1)

    fmt.Printf("Mf1 = %f\n", struct1.Mf1)

}

// 输出

Mi1 = 10

Mf1 = 16.000000

# 4. 带标签的结构体

• 结构体中的字段除了有名字和类型外，还有一个可选的 标签(tag) : 是一个附属于字段的字符串，可以是文档或其他的重要标记，标记内容不可以在一般的变成中使用，只有 包 reflect 能获取

• reflect 可以在 运行时自省类型，屬性和方法，使用 reflect.TypeOf(variable) 获取变量的正确类型， reflect.TypeOf(struct) 可以通过返回值的 Field 来索引结构体的字段，然后使用其 Tag 属性

package main

import (

    "fmt"

    "reflect"

)

type TagType struct { // tags

    //json db 格式化使用形式 `json:"name"db:"name"`

    field1 bool   "An important answer"

    field2 string "The name of the thing"

    field3 int    "How much there are"

}

//json 序列化时使用 tag

type TagType struct { // tags

    field1 bool   "An important answer"

    field2 string "The name of the thing"

    field3 int    "How much there are"

}

func main() {

    tt := TagType{true, "Barak Obama", 1}

    for i := 0; i < 3; i++ {

        refTag(tt, i)

    }

}

func refTag(tt TagType, ix int) {

    ttType := reflect.TypeOf(tt)

    ixField := ttType.Field(ix)

    fmt.Printf("%v\n", ixField.Tag)

}

// 输出

An important answer

The name of the thing

How much there are

# 5. 匿名字段和内嵌结构

• 结构体可以包含一个或多个匿名 (或内嵌字段), 即字段没有显示的名字，只有字段类型是必须的，此时类型就是字段的名字。匿名字段本身可以是一个结构体类型，即 结构体可以包含内嵌结构体
• Go 语言中 通过内嵌或组合实现 模拟类的继承行为，Go 语言中，相比较继承，组合更受青睐
• 通过类型 outer.int 的名字来获取存储在匿名字段中的数据，因此 (在一个结构体中每一种数据类型只能有一个匿名字段)

type innerS struct {

    in1 int

    in2 int

}

type outerS struct {

    b    int

    c    float32

    int  // anonymous field

    innerS //anonymous field

}

func main() {

    outer := new(outerS)

    outer.b = 6

    outer.c = 7.5

    outer.int = 60

    outer.in1 = 5

    outer.in2 = 10

    fmt.Printf("outer.b is: %d\n", outer.b)

    fmt.Printf("outer.c is: %f\n", outer.c)

    fmt.Printf("outer.int is: %d\n", outer.int)

    fmt.Printf("outer.in1 is: %d\n", outer.in1)

    fmt.Printf("outer.in2 is: %d\n", outer.in2)

    // 使用结构体字面量

    outer2 := outerS{6, 7.5, 60, innerS{5, 10}}

    fmt.Println("outer2 is:", outer2)

}

内嵌结构体

• 结构体也是一种数据类型，因此也可以做为一个匿名字段来使用，外层结构体通过 outer.struct.File 直接进入内层结构体的字段，内层结构体甚至可以来自其他包，内层结构体被简单的插入或者内嵌进外层结构体，这种 简单继承机制提供了一种方式，使得可以从另一个或者一些类型继承部分或全部实现

package main

import "fmt"

type A struct {

    ax, ay int

}

type B struct {

    A

    bx, by float32

}

func main() {

    b := B{ A{1,2}, 3.0, 4.0}

    fmt.Println(b.ax, b.ay, b.bx, b.by)

    fmt.Println(b.A)

}

// 输出

1 2 3 4 

{1,2}

命名冲突 当两个字段拥有相同的名字 (可能是继承来的名字)

1. 外层名字会覆盖内层名字 (但是两者的内存空间都保留), 这提供了一种重载字段或方法的方式；
2. 如果相同的名字在同一级别出现两次，且这个名字被程序使用了，将会应发一个错误 (不使用则不影响), 没有办法解决这种问题引起的二义性
3. 类型别名：处理 JSON 相关操作 type strMap2Any = map[string]interface {}

/**

* 规则 2: 使用 c.a 是错误的，无法确定是 c.A.a 还是 c.B.a , 会导致编译器错误:

* ambiguous DOT reference c.a disambiguate with either c.A.a or c.B.a。

*/

type A struct{a int}

type B struct{a, b int}

type c struct {A; B}

func main {

    var c C

	//c.a = 11   ambiguous selector c.a 模棱两可的选择器

	c.A.a = 10

	c.B.a = 50

	c.B.b = 30

	fmt.Printf("%+v",c)

}

输出 : {A:{a:10} B:{a:50 b:30}}

/**

* 规则 1: 使用 d.b 是没问题的：获取的是 float32, 而不是 B 的 b

* 想要内层的 b 可以通过 d.B.b 得到

*/

type D struct {B; b float32}

# 6. 结构体方法

1. 在 Go 语言中，结构体就像是类的一种简化形式，Go 方法是作用在接受者 (receiver) 上的一个函数，接收者是某种类型的变量。因此方法是一种特殊类型的函数.
2. 接收者类型 (几乎) 是任何类型，任何类型都可以有方法，甚至是函数类型，可以是 int、bool、string 或数组的别名类型，但 接收者不能是一个接口类型，因为接口是一个抽象定义，但是方法是具体实现.
3. 接收者不能是一个指针类型，但是可以是任何其他允许类型的指针
4. Go 语言中，类型的代码和绑定的方法可以 在不同源文件，但是必须是同一个包.
5. 因为方法是函数，所以不允许方法重载，即 对于一个类型只能有一个给定名称的方法，但基于接收者类型，是有重载的：具有相同名字的方法可以再两个或者多个不通风的接收者类型上存在

// 别名类型 没有原始类型上已经定义过的方法

func (a *denseMatrix) Add(b Matrix) Matrix

func (a *sparseMatrix) Add(b Matrix) Matrix

# 1. 定义方法的一般格式 :

• recv 就像是面向对象语言中的 this 或 self , Go 中并没有这两个关键字，可以使用 this 或 self 作为 receiver 的名字

// 在方法名之前，func 关键字之后的括号中指定 receiver

func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }

// 如果方法不需要使用 recv 的值，可以用 _替换

func (_ recevier_type) methodName(parameter_lsit) (return_value_list) {...}

/**

* 如果 `recv` 是 `receiver` 的实例，`Method` 是方法名

* 那么方法调用遵循传统的 `object.name` 选择器符号:

*/

type Recevier struct{

    ...

}

func (r recevier) Method(){

    ...

}

var recv Recevier

recv.Method()

# 2. 类型和对应方法的定义域

1. 类型和作用在其上的方法必须在同一个包定义，类型在其他 或 非本地的包中定义方法都会报错
2. 通过 定义类型的别名类型，然后再为别名类型定义方法。或将其 作为匿名类型嵌入在新的结构体中 (方法只在别名类型上有效)

// 别名类型定义方法

type myTime time.Time

func (t myTime) cropTime() string {

    return t.LocalTime().String()[0:3]

}

// 匿名嵌入结构体中

type myTime struict { time.TIme /* 匿名字段 */}

func (t myTime) cropTime() string { 

	return t.LocalTime().String()[0:3]

}

# 3. 函数和方法的区别

1. 函数将变量作为参数: Function (recv)
2. 方法在变量上被调用: recv.Method()
3. 在接受者是指针时，方法可以改变接收者的值 (或状态), 函数将参数作为指针传递也可以做到
4. 接收者必须有一个 显示的名字，这个名字必须在方法中被使用
5. receiver_type 叫做 (接收者) 基本类型，这个类型必须在和方法同样的包中被声明
6. Go 中 (接收者) 类型关联的方法不必写在类型结构体中，耦合更加宽松；类型和方法之间的关联由接收者建立
7. 方法 没有和 数据定义 (结构体) 混合在一起：两者是正交的类型；表示 ==(数据)== 和行为 (方法) 是独立的

# 4. 指针或值作为接收者

1. 鉴于性能原因， recv 最常见的是一个指向 receiver_type 的指针
2. 想要方法改变接收者的数据，就在接收者类型的指针上定义该方法，否则就在普通的值类型上定义方法
3. Go 为我们做了探测工作，我们无需指出是否在指针上调用方法
4. 指针方法和值方法都可以在指针或非指针上被调用

# 5. 方法和未导出字段

1. getter 和 setter , 对 导出类型 Person 的未导出字段进行赋值和获取
2. 对象的字段 (属性) 不应该由 2 个或 2 个以上的线程在同一时间改变，如果程序发生这种情况，为了安全并发访问，可以使用包 sync 中的方法

package person

type Person struct {

    field1 string

    field2  string

}

func (p *Person) Field1() string {

    return p.field1

}

func (p *Person) SetField1(newName string) {

    p.firstName = field1

}

# 6. 内嵌类型的方法和继承

1. 当一个匿名类型被 内嵌在结构体中 时，匿名类型 的可见方法 也同样被内嵌，效果等同于 继承 了这些相关方法: 将父类型放在子类型中来实现亚型。这个机制提供了一种简单的方式来模拟经典面向对象语言中的子类和继承相关的效果
2. 内嵌将已经存在类型的字段和方法注入到 另一个类型中：匿名字段上 的 方法 "晋升" 为外层类型的方法，类型也可以有只作用于本身实例而不作用于内嵌 "父类型" 的方法
3. 覆写方法 (像字段一样) : 和内嵌方法具有相同名字的外层类型的方法会覆写内嵌类型对应的方法
4. 因为一个结构体可以嵌入多个匿名类型，所以可以实现简单版本的 多重继承.
5. 结构体内嵌 同包结构体时，可以彼此访问对方所有的字段和方法

# 7. 在类型中嵌入功能

1. 聚合 (或组合): 包含一个所需功能类型的具名字段 (需要使用 field.func () 调用对应的聚合方法)
2. 内嵌：内嵌 (匿名的) 所需功能类型 (可以直接使用匿名字段方法)
3. 内嵌类型嵌入其他类型时，那些类型的方法也可以直接在外层类型中使用

# 8. 多重继承

1. 多重继承：类型获得多个父类型行为的能力，Go 语言中，通过在类型中嵌入所必要的父类型，可以简单的实现多继承.
2. 多重继承结构体使用 &struct{ field: "" } 进行赋值时要么 全省略字段值，要么全使用字段值

type Base struct {

	id string

}

func (b *Base) Id() string{

	return b.id

}

func (b *Base) SetId(id string) {

	b.id = id

}

type Person struct {

	Base

	firstName string

	lastName string

}

type Employee struct {

	Person

	salary float32

}

func test02() {

	// 全使用字段名进行对应赋值

    emp := &Employee{Person: Person{Base: Base{id:"101010"},firstName: "black",lastName:"cat"} ,salary: 36.5}

    // 全省略字段名进行赋值

	emp := &Employee{Person{Base{"1001101"},"white","cat"},6600.5}

	fmt.Printf("%+v\n",emp)

	fmt.Printf("%+v\n",emp.id)

}

# 9. 通用方法和方法命名

1. 在编程中 一些基本操作会一遍遍重复出现，例如 == 打开（Open）、关闭（Close）、读（Read）、写（Write）、排序（Sort）== 等等，并且都有一个大致的意思。具体的实现可能前差万别，但是基本的概念是一致的.
2. Go 语言中通过使用接口，标准库广泛的应用了这些规则，在标准库中这些方法都有一致的名字，如 Open(),Read(),write() 等.
3. 书写规范的 Go 程序，就应该遵守这些约定，get 方法合适的名字和签名

# 10. Go 语言的方法和其他面向对象语言比较

1. Go 语言中，类似其他语言的继承层次完全没必要，如果方法在此类型定义了，就可以调用，和其他类型上是否存在这个方法没有关系，因此 Go 在这方面具有更强大的灵活性
2. Go 不需要一个显示的类定义，"类" 是通过提供一组作用于一个共同类型的方法集来隐式定义。类型可以是 结构体 或 任何用户自定义类型
3. 在 Go 中，类型就是类 (数据和关联的方法). Go 没有类似面向对象语言的类继承概念，继承的两个好处：代码重复 和 多态.
4. 在 Go 中，代码复用通过组合和委托实现，多态通过接口的使用来实现：有时候也称为 组件编程 (Component Programming)
5. 相比于类继承，Go 的接口提供了更强大，更简单的多态行为
6. goop 包，给 Go 提供了 JavaScript 风格的对象 (基于原型的对象), 并且支持多重继承和类型独立分派

# 7. 类型的 String 方法和格式化描述符

1. 当定义了一个有很多方法的类型时，大概率会使用 String() 方法来定制类型的字符串形式的输出 (一种可阅读性和打印性的输出).
2. String() 方法会被用在 fmt.Printf() 中生成默认的输出，等同于使用格式化描述符 % v 产生的输出， fmt.Print() 和 fmt.Println() 也会自动使用 String() 方法
3. 在 String() 方法中调用涉及 String() 方法的方法会导致无限递归，并很快导致内存溢出，例如 (在 T.String() 中调用 fmt.Sprintf() , 但 fmt.Printf() 又会反过来调用 T.String() ...)

# 8. 垃圾回收和 SetFinalizer

1. Go 开发者不需要写代码来释放程序中不再使用的变量和结构占用的内存
2. Go 运行时有一个独立的进程，即垃圾收集器 (GC), 会处理，GC 进程搜索不在使用的变量然后释放其内存，可以通过 runtime 包访问 GC 进程
3. 通过调用 runtime.GC() 函数可以显示的触发 GC, 但这些之爱子某些罕见的场景下才有用，比如 当内存资源不足时调用 runtime.GC() , 它会在此函数执行的点上立即释放一大片内存，此时程序可能会短暂的性能下降 (因为 GC 进程在执行)

获取当前的内存状态

输出当前已分配内存的总量，单位是 KB

// fmt.Printf("%d\n", runtime.MemStats.Alloc/1024)

// 此处代码在 Go 1.5.1 下不再有效，更正为

var m runtime.MemStats

runtime.ReadMemStats(&m)

fmt.Printf("%d Kb\n", m.Alloc / 1024)

# 3. 接口 (Interface) 与反射 (Reflection)

# 1. 接口的定义

1. Go 语言没有，类和继承的概念，但是有非常灵活的接口概念，通过接口可以实现很多面向对象的特性.
2. 接口提供了一种方式来说明 对象的行为
3. 接口的名字通常 由方法名加 [e]r 后缀组成，例如: Printer,Reader,Writer; 当后缀 er 不合适时，如 Recoverable , 接口以 able 结尾，或以 I 开头

接口定义:

type Namer interface {

    Method1(param_list) return_type

    Method2(param_list) return_type

}

• Go 语言中接口可以有值，一个接口类型的变量 或 一个接口值: var ai Namer , ai 是一个多字 (multiword) 数据结构，它的值时 nil . 其本质上是一个指针，虽然不尽相同，指向接口的指针是非法的，没有任何作用，还会导致代码错误

1. 类型 (比如结构体) 可以实现某个接口的方法集；这个实现可以描述为，该类型的变量上的每一个具体方法所组成的集合，包含了该接口的方法集.
2. 实现了 Namer 接口的类型变量可以赋值给 ai (即 receiver 的值), 方法表指针 (method table ptr) 就指向了当前的方法实现。当另一个实现了 Namer 接口类型的变量被赋给 ai , receiver 的值和方法表指针也会相应改变
3. 类型不需要显示声明它实现了某个接口: 接口被隐式的实现，多个类型可以实现同一个接口
4. 实现某个接口的类型 (除了实现接口方法外) 可以有其他的方法
5. 一个类型可以实现多个接口
6. 接口类型可以包含一个实例的引用，该实例的类型实现了此接口 (接口是动态类型).

• 结构体 Square 实现了接口 Shaper , 所以可以将一个 Square类型 的变量赋值给 一个接口类型变量: areaIntf = sql
• 接口变量包含一个指向 Square 变量的引用，通过它可以调用 Square 上的 Area() 方法
• 接口变量 里包含了 接收者实例的值 和 指向对应方法表的指针

type Shaper interface {

    Area() float32

}

type Square struct {

    side float32

}

func (sq *Square) Area() float32 {

    return sq.side * sq.side

}

func main() {

    sq1 := new(Square)

    sq1.side = 5

    var areaIntf Shaper

    areaIntf = sq1

    fmt.Printf("The square has area: %f\n", areaIntf.Area())

}

# 2. 接口嵌套接口

• 一个接口可以包含一个或多个其他的接口，相当于将内嵌接口的方法列举在外层接口中一样
• 例如 File 包含了 ReadWrite 和 Lock 的所有方法，还额外有一个 Close() 方法

type ReadWrite interface {

    Read(b Buffer) bool

    Write(b Buffer) bool

}

type Lock interface {

    Lock()

    Unlock()

}

type File interface {

    ReadWrite

    Lock

    Close()

}

# 3. 类型断言

检测和转换接口变量的类型

1. 一个接口类型的变量 varI 可以包含任何类型的值，必须有一种方式来检测它的 动态 类型，运行时在变量中存储的值的实际类型
2. 在执行过程中动态类型可能会有所不同，但总是可以分配给接口变量本身的类型。通常使用 类型断言 来测试，某个时刻 varI 是否包含类型 T 的值.

v := varI.(T)		//unchecked type assertion

//var 必须是一个接口变量，否则编译器会报错 :

invalid type assertion: varI.(T) (non-interface type (type of varI) on left)

3. 类型断言可能是无效的，编译器会尽力检查转换是否有效，但是不可能遇见所有的可能性.
4. 转换在程序运行时失败会导致错误法发生，更安全的方式是使用以下形式来进行断言

• 转换合法: v 是 varI 转换到类型 T 的值， ok 是 true
• 转换失败: v 是类型 T 的零值， ok 是 false , 也没有运行时错误

if v, ok := varI.(T); ok { // checked type assertion

    Process(v)

    return

}

// 只测试是否能够成功转换

if _, ok := varI.(T); ok {

    ···

}

# 4. 类型判断

1. 接口变量的类型也是可以使用一种特殊形式的 switch 来检测 : type-switch

• t 得到了 areaIntf 的值和类型，所有 case 语句中列举的类型 ( nil 除外) 都必须实现对应的接口
• 如果被检测类型没有在 case 列举的类型中，就会执行 default 语句
• type-switch 进行运行时类型分析， case 分支中不允许有 fallthrough

switch t := areaIntf.(type) {

case *Square:

    fmt.Printf("Type Square %T with value %v\n", t, t)

case *Circle:

    fmt.Printf("Type Circle %T with value %v\n", t, t)

case nil:

    fmt.Printf("nil value: nothing to check?\n")

default:

    fmt.Printf("Unexpected type %T\n", t)

}

/* 输出 */ :  Type Square *main.Square with value &{5}

2. type-switch 处理来自外部的，类型未知的数据时，例如 解析注入 JSON 或 XML 编码的数据，类型测试和转换会非常有用
3. 如下展示了一个类型分类函数，其拥有一个可变长度参数，可以是任意类型的数组，会根据数组元素的实际类型执行不同的动作:

func classifier(items ...interface{}) {

    for i, x := range items {

        switch x.(type) {

        case bool:

            fmt.Printf("Param #%d is a bool\n", i)

        case float64:

            fmt.Printf("Param #%d is a float64\n", i)

        case int, int64:

            fmt.Printf("Param #%d is a int\n", i)

        case nil:

            fmt.Printf("Param #%d is a nil\n", i)

        case string:

            fmt.Printf("Param #%d is a string\n", i)

        default:

            fmt.Printf("Param #%d is unknown\n", i)

        }

    }

}

# 5. 测试一个值是否实现了某个接口

1. 接口是一种契约，实现类型必须满足它
2. 编写参数是接口变量的函数，使其更具有一般性
3. 接口让代码更具有普适性

// 判断 v 是否实现了 Stringer 接口

type Stringer interface {

    String() string

}

if sv, ok := v.(Stringer); ok {

    fmt.Printf("v implements String(): %s\n",sv.String())	

}

# 6. 方法集与接口

1. 作用于变量上的方法不区分变量是 指针还是值，但碰到接口类型值时，情况会变得复杂
2. 接口变量中存储的具体值是不可寻址的，但不使用不当时编译器会给出错误
3. 在接口上调用方法时，必须有和方法定义时相同的接收者类型或者是可以从具体类型 P 直接辨识的:

• 指针方法可以通过指针调用
• 指针方法可以通过值使用
• 接收者是值的方法可以通过指针调用，因为指针会首先被解引用
• 接收者是指针的方法不可以通过值调用，因为存储在接口中的值没有地址

4. Go 语言规范定义了接口方法集的调用规则:

• 类型 T 的可调用方法集合包含接受者为 *T 或 T 的所有方法集
• 类型 T 的可调用方法集包含接收者为 T 的所有方法
• 类型 *T 的可调用方法集不包含接收者为 T 的方法

# 7. 使用 Sorter 接口排序

1. 要对一组数字或字符串排序，只需要实现三个方法:

• 反映元素个数的 Len()
• 比较第 i 和 j 个元素的 Less(i,j)
• 交换第 i 和 j 个元素的 Swap(i,j)

// Sort 函数接收一个接口类型的参数: Sorter

type Sorter interface {

    Len() int

    Less(i,j int) bool

    Swap(i, j int)

}

2. 冒泡排序 Sorter 实现

func Sort(data Sorter) {

    for pass :=1; pass < data.Len(); pass++ {

        if data.Less(i+1, i) {

            data.Swap(i,i + 1)

        }

    } 

}

3. 多种数据类型 基于 Sorter 接口的冒泡排序

package sort

type Sorter interface {

    Len() int

    Less(i, j int) bool

    Swap(i, j int)

}

func Sort(data Sorter) {

    for pass := 1; pass < data.Len(); pass++ {

        for i := 0; i < data.Len()-pass; i++ {

            if data.Less(i+1, i) {

                data.Swap(i, i+1)

            }

        }

    }

}

func IsSorted(data Sorter) bool {

    n := data.Len()

    for i := n - 1; i > 0; i-- {

        if data.Less(i, i-1) {

            return false

        }

    }

    return true

}

// Convenience types for common cases

type IntArray []int

func (p IntArray) Len() int           { return len(p) }

func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }

func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

type StringArray []string

func (p StringArray) Len() int           { return len(p) }

func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }

func (p StringArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

// Convenience wrappers for common cases

func SortInts(a []int)       { Sort(IntArray(a)) }

func SortStrings(a []string) { Sort(StringArray(a)) }

func IntsAreSorted(a []int) bool       { return IsSorted(IntArray(a)) }

func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }

# 8. 读和写

1. 读和写是软件中普遍的行为，一般用于 读写文件，缓存 (比如字节或字符串切片), 标准输入输出，标准错误以及网络连接，管道等等，或者 自定义类型。为了让代码尽可能通用，GO 采取了一致的方式来读写数据.
2. io 包提供了用于读和写的接口 io.Reader 和 io.Writer :

type Reader interface {

    Read(p []byte) (n int,err error)

}

type Writer interface {

    Write(p []byte) (n int,err error)

}

3. 只要类型实现了读写接口，提供 Read() 和 Write 方法，就可以从中 读取或写入数据.
4. 一个对象是可读的，必须实现 io.Reader 接口，

• 这个接口只有一个签名是 Read(p []byte) (n int,err error) 的方法，
• 它从调用它的对象读取数据，并把读取到的数据放入参数的字节切片中，返回读取字节数和一个 error 对象，如果没有发生错误返回 nil
• 如果已经达到输入的尾端，会返回 io.EOF("EOF") , 如果读取过程中发送了错误，就会返回具体的错误信息

5. 一个对象是可写的，其必须实现 io.worter 接口

• 这个接口也只有一个签名是 Write(p []byte) (n int,err error) 的方法
• 该方法将指定字节切片中的数据写入调用它的对象中，然后返回实际写入的字节数和一个 error 对象 (如果没有发生错误就是 nil ).

6. io 包中的 Readers 和 Writers 都是不带缓冲的，bufio 包提供了对应的带缓冲的操作，在读写 UTF-8 编码的文本时尤其有用.

# 9. 空接口

概念：空接口或者最小接口不包含任何方法，它对实现比作任何要求

• 任何其他类型都实现了空接口，(它不仅仅像 Java/C# 中的 Object 引用类型)

• any 或 Any 是空接口一个很好的别名 或 缩写

• 空接口类似 Java/C# 中所有类的基类: Object 类，二者目标也很接近.

• 可以给一个空接口类型的变量 var val interface {} 赋任何类型的值.

type Any interface{ }

• val 可依次被赋予一个 int , string 和 Person 实例的值，然后使用 type-switch 来测试它的实际类型。每个 interface{}
• 变量在内存中占据两个字长：一个用来存储它包含的类型，另一个用来存储它包含的 数据或指向数据的指针

# 1. 构建通用类型或者包含不同类型变量的数组

• 给空接口定义一个别名类型 Element :

type Element interface{}

• 定义一个容器类型的结构体 Vector , 包含一个 Element 类型元素的切片:

type Vector struct {

    a []Element

}

• Vector 能放置任何类型的变量，应为任何类型都实现了空接口，实际上 Vector 里放的每个元素都可以是不同类型的变量。为其定义一个 At() 方法用于返回第 i 个元素 :

func (p *Vector) At(i int) Element {

    return p.a[i]

}

• 定义一个 Set() 方法用于设置第 i 个元素的值:

func (p *Vector) set(i int,e Element) {

    p.a[i] = e

}

• Vector 中存储的所有元素都是 Element 类型，要得到它们的原始类型 ( unboxing : 拆箱) 需要用到类型断言
• 类型断言总是在运行时才执行，因此它会产生运行时错误: The Compiler rejects assertions guaranteed to fail

# 2. 复制数据切片至空接口切片

• Go 中 无法将 myType 类型的数据切片直接复制到一个 空接口切片 中

/**

* 使用这种方式赋值会引起编译时报错 

* cannot use dataSlice (type [] myType) as type [] interface {} in assignment	

*/

var dataSlice []myType = FuncReturnSlice()

var interfaceSlice []interface{} = dataSlice

• 空接口切片和 myType 类型的切片在内存中的布局是不一样的，必须使用 for-range 语句来一个个显示赋值

var dataSlice []myType = FuncReturnSlice()

var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))

for i, d := range dataSlice {

    interfaceSlice[i] = d

}

# 3. 反射包

1. 方法和类型的反射

• 通过反射可以分析一个结构体，反射是用程序检查其所拥有的结构，尤其是类型的一种能力；是元编程的一种形式
• 反射可以在运行时检查类型和变量，例如: 变量的大小，方法 和 动态的调用这些方法
• 对于没有源码的包，反射尤其有用，反射是一个强大的工具，除非真得有必要，否则应当避免使用
• 变量的最基本信息就是类型和值：反射包的 Type 用来表示一个 Go 类型，反射包的 value 为 Go 值提供了反射接口
• reflect.TypeOf 和 reflect.ValueIf , 返回被检查对象的类型和值.
• i 的值包含一个 type 和 value , 反射可以从接口值反射到对象，也可以从对象反射回接口值

/*

* 反射实际上是通过检查一个接口的值，变量首先被转换成空接口

*/

func TypeOf(i interface{}) Type

func ValueOf(i interface{}) Value

reflect 常用方法 :

# 4. 通过反射修改 (设置) 值

# 5. 反射结构

1. 有些时候需要反射一个结构类型. NumField() 方法返回结构内的字段数量；通过一个 for 循环用索引取得每个字段的值 Field(i)
2. 通过索引 n 来调用签名在结构体上的方法: Method(n).Call(nil)
3. 如果尝试修改结构体中的 不可导出字段 (首字母小写), 会得到一个错误

panic: reflect.Value.SetStringusing value obtained using unexported field

4. 结构体中只有被导出字段 (首字母大写) 才是可设置的， type.Field(i).Name (得到结构体中第 i 个字段名)

type T struct{

    A int

    B string

}

func main(){

    t := T{23,"skidoo"}

    s := reflect.ValueOf(&t).Elem()

    typeOfT := s.Type()

for i :=0; i < s.NumField(); i++{

        f := s.Field(i)

        fmt.Printf("%d: %s %s = %v\n", i,

            typeOfT.Field(i).Name, f.Type(), f.Interface())

}

    s.Field(0).SetInt(77)

    s.Field(1).SetString("Sunset Strip")

    fmt.Println("t is now", t)

}

输出: 

0

1

t is now {77, SunsetStrip}

# 10.Printf 和反射

GO 语言标准库中，反射的功能被大量的使用.fmt 包中的 printf (以及其他格式化输出函数) 都会使用反射来分析它的 ... 参数

Printf 的函数声明为:

• Printf 中的 ... 参数为空接口类型，
• Printf 使用反射包来解析这个参数列表。所以，Printf 能够知道每个参数的类型
• 使用 type-switch 来推导参数类型，并根据类型输出每个参数的值.

func Printf(format string,args ...interface{}) (n int,err error)

# 11. 接口与动态类型

Go 的动态类型

1. 经典面向对象语言 (c++,Java 和 c#) 中数据和方法被封装为类的概念：类包含两者且不能剥离
2. Go 没有类：数据 (结构体或更一般的类型) 和 方法是一种松耦合的正交关系
3. Go 中的接口跟 Java/C# 类似：都必须提供一个指定方法集的实现。但更加灵活通用：任何提供了接口方法实现代码的类型都隐式实现了该接口，而不用显示的声明
4. Go 是唯一结合了接口值，静态类型检查 (该类型是否实现某个接口), 运行时动态转换的语言，并且不需要显示的声明类型是否满足某个接口.
5. 接收一个 (或多个) 接口类型作为参数的函数，其实参可以是任何实现了该接口的类型变量。实现了某个接口的类型可以被传递给任何以此接口为参数的函数

动态方法调用

1. Python,Ruby 这类语言，动态类型是延迟绑定的 (在运行时进行): 方法只是用参数和变量简单的调用，然后运行时才解析 (会产生更大的编码量和更多的测试工作)
2. Go 的实现与此相反，通常需要编译器静态检查的支持：当变量被赋值给一个接口类型的变量时，编译器会检查其是否实现了改接口的所有函数.
3. 如果方法调用作用于像 interface {} 的 "泛型" 上，可以通过类型断言来检查变量是否实现了相应接口
4. Go 提供了动态语言的优点，却没有其他语言在运行时可能发送错误的缺点 (可以减少单元测试)
5. Go 的接口提高了代码的分离度，改善了代码的复用性，使代码开发中的设计模式更容易实现.Go 接口还能实现依赖注入模式

接口的提取

1. 提取接口 是非常有用的设计模式，可以减少需要的类型和方法数量，且不需要像传统的基于类的面向对象语言那样维护整个类的层次结构
2. Go 可以让开发者找出自己写的程序中的类型。如果有一些拥有共同行为的对象，并且开发者想要抽象出这些行为，就可以创建一个接口来使用.
3. 类型想要实现某个接口，本身无需改变，只需要在这个类型上实现新的方法；不用提前设计出所有的接口， 整个设计可以持续演进，而不用废弃之前的决定.

显式地指明类型实现了某个接口

• 希望某个接口的类型显式的声明它们实现了这个接口，可以向方法集中添加一个具有描述性名字的方法.

type Fooer interface {

    Foo()

    ImplementsFooer()

}

• 类型 Bar 必须实现 ImplementsFooter 方法来满足 Fooer() 接口，以清楚记录这个事实
• 大部分代码并不使用这样的约束，因为限制了接口的实用性
• 有些时候，这样的约束在大量相似的接口中被用来解决歧义.

type Bar struct{}

func (b Bar) ImplementsFooer() {}

func (b Bar) Foo() {}

空接口和函数重载

• Go 语言中函数重载可以用可变参数 ...T 作为函数最后一个参数来实现。如果将 T 换为空接口，那么任何变量都是满足 T (空接口) 类型的，这样就允许传递任何数量任何类型的参数给函数，即重载的实际含义
• 函数 fmt.Printf 通过枚举 slice 类型的实参动态确定所有参数的类型。并查看每个类型是否实现了 String() 方法

// 函数 fmt.Printf 就是这样实现的

fmt.Printf(format string,a ...interface{}) (n int,errno error)

接口的继承

• 当一个类型包含 (内嵌) 另一个类型 (实现了一个或多个接口) 的指针时，这个类型就可以使用 (另一个类型) 所有与的接口方法.

type Task struct {

    Command string

    *log.Logger

}

• task 的工厂方法

func NewTask(command string,logger *log.Logger) *Task {

    return &Task{command, logger}

}

• 当 log.Logger 实现了 Log () 方法后，Task 的实例 task 就可以调用该方法:

task.Log()

• 类型可以通过继承多个接口来提供像 多继承 一样的特性:

type ReaderWriter struct {

    *io.Reader

    *io.Writer

}

• 以上原理被应用于整个 Go 包，多态用得越多，代码就相对越少。这被认为是 Go 编程中的重要的最佳实践
• 有用的接口可以在开发的过程中被归纳出来。添加新接口非常容易，因为已有的类型不用变动 (仅仅需要实现新接口的方法).
• 已有的函数可以拓展为使用接口类型的约束性参数：通常只有函数签名需要改变。对比于基类的 oo 类型的语言在这种情况下则需要适用整个类型层次结构的变化

# 12.Go 中的面向对象

Go 没有类，而是松耦合的类型，方法对接口的实现.

1. 封装 (数据隐藏): Go 将其他 oo 语言的多个访问层次简化为 2 层:

• 包的范围：通过表示符首字母小写，对象 只在自己所在的包内可见
• 可导出的：通过标识符首字母大写，对象 对所在包以外的也可见

2. 继承：用组合实现：内嵌一个 (或多个) 包含想要的行为 (字段和方法) 的类型；多重继承可通过内嵌多个类型实现
3. 多态：用接口实现：某个类型的实例可以赋给其所实现的任意接口类型的变量。类和接口是松耦合的，并且多继承可以通过实现多个接口实现.
4. GO 接口间是不相关的，且是大规模变成和可适应的演进类型设计的关键.

# 4. 读写数据

# 1. 读取用户的输入

Go 语言获取用户的键盘 (控制台) 输入，从键盘和标准输入 os.Stdin 读取输入，最简单的办法是使用 fmt 包提供的 Scan 和 Sscan 开头的函数.

1. fmt 包下的 scan 系列方法，扫描来自标准输入的文本或字符，将空格分隔的值依次存放到后续的参数内.(传递参数地址接收)

2. bufio 包提供缓冲读取 (buffered reader) 来读取数据

• inputReader 是一个指向 bufio.Reader 的指针. inputReader := bufo.NewReader(os.Stdin) 会创建一个读取器，并将其与标准输入绑定.

• bufio.NewReader() 构造函数的签名为: func NewReader(rd io.Reader) *Reader

  • 函数的实参可以是满足 io.Reader 接口的任意对象 (任意包含有适当的 Read() 方法的对象)
  • 函数返回一个新的带缓冲的 io.Reader 对象，将从指定读取机器 (例如 os.Stdin ) 读取内容
  • 返回的读取器对象提供一个方法 ReadString(delim byte) , 该方法从输入中读取内容，直到碰到 delim 指定的字符，然后将读取到的内容连同 delim 字符一起放到缓冲区

• ReadString 返回读取到的字符串，如果碰到错误则返回 nil , 如果一直读取到文件结束，则返回读取到的字符串和 io.EOF 如果读取过程中没有遇到 delim 字符，将返回错误 err != nil

• 屏幕是标准输出 os.Stdout , os.Stderr 用于显示错误信息，大多数情况下等同于 os.Stdout

inputReader := bufio.NewReader(os.Stdin)

input, err := inputReader.ReadString('\n')

缓冲读取:

# 2. 文件读写

# 1. 读文件

1. Go 语言中，文件使用指向 os.File 类型的指针来表示，也叫做文件句柄，标准输入 os.Stdin 和 标注输出 os.Stdout 的类型都是 *os.File

2. 变量 inputFile 是 *os.File 类型的。该类型是一个结构，表示一个打开文件的描述符 (文件句柄). 使用 os 包中的 Open 函数来打开文件，函数的参数是文件名，类型为 string . 下面程序中是以只读模式打开 input.dat 文件.

   • 文件不存在，或者程序没有足够的权限打开文件，Open 函数会返回一个错误: inputFile, inputError = os.Open("input.dat")

   • 文件正常打开，使用 defer inputFile.Close() 语句确保在程序退出前关闭该文件。使用 bufio.NewReader 获取读取器变量.

   • 通过使用 bufio 包提供的读取器 (写入器类似), 可以方便的操作相对高层的 string 对象，避免操作者底层的字节

   • 在无限循环中使用 ReadString('\n') 或 ReadBytes('\n') 将文件内容逐行读取出来

   • Unix 和 Linux 的行结束符是 \n , 而 Windows 的行结束符是 \r\n . 在使用 ReadString 和 ReadBytes 方法的时候，无需关心操作系统的类型，直接使用 \n 即可，亦可使用 ReadLine() 方法来实现相同的功能

   • 读取到文件末尾，变量 readerError 的值将变成非空 (其值常量为 io.EOF ) 就会执行 return 语句退出循环

func main() {

    inputFile, inputError := os.Open("input.dat")

    if inputError != nil {

        fmt.Printf("An error occurred on opening the inputfile\n" +

            "Does the file exist?\n" +

            "Have you got acces to it?\n")

        return // exit the function on error

    }

    defer inputFile.Close()

    inputReader := bufio.NewReader(inputFile)

    for {

        inputString, readerError := inputReader.ReadString('\n')

        fmt.Printf("The input was: %s", inputString)

        if readerError == io.EOF {

            return

        }      

    }

}

3. 将整个文件的内容读取到一个字符串里 :
   • io/ioutil 包里的 ioutil.ReadFile() 方法，
   • 该方法第一个返回值的类型是 []byte , 里面存放读取到的内容，
   • 第二个返回值是错误，如果没有错误发生，第二个值为 nil . 函数 WriteFile() 可以将 []byte 值写入文件

func main() {

    inputFile := "products.txt"

    outputFile := "products_copy.txt"

    buf, err := ioutil.ReadFile(inputFile)

    if err != nil {

        fmt.Fprintf(os.Stderr, "File Error: %s\n", err)

        // panic(err.Error())

    }

    fmt.Printf("%s\n", string(buf))

    err = ioutil.WriteFile(outputFile, buf, 0644) // oct, not hex

    if err != nil {

        panic(err.Error())

    }

}

4. 带缓冲的读取
   • 多数情况下，文件的内容是不按行划分的，或者是一个二进制文件. ReadString () 就无法使用了，可以使用 bufio.Reader 的 Read (), 只接收一个参数:

buf := make([]byte,1024)

//n 表示读取到的字节数

n, err := inputReader.Read(buf)

if (n == 0) {break}

5. 按列读取文件的数据

   • 如果文件是按列并用空格分割的，可以使用 fmt 包提供的以 FScan 开头的一系列函数来读取.

   	func main() {
   	file, err := os.Open("products2.txt")
   	if err != nil {
   	panic(err)
   	}
   	defer file.Close()
   	var col1, col2, col3 []string
   	for {
   	var v1, v2, v3 string
   	_, err := fmt.Fscanln(file, &v1, &v2, &v3)
   	// scans until newline
   	if err != nil {
   	break
   	}
   	col1 = append(col1, v1)
   	col2 = append(col2, v2)
   	col3 = append(col3, v3)
   	}
   	fmt.Println(col1)
   	fmt.Println(col2)
   	fmt.Println(col3)
   	}

   • path 包中包含一个子包 filepath , 这个子包提供了跨平台的函数，用于处理文件名和路径.
   • 例如: Base() 函数用于获取路径中的最后一个元素 (不包含后面的分隔符)

   	import "path/filepath"
   	filename := filepath.Base(path)

6. compress 包提供了，读取压缩文件的功能，支持的压缩文件格式为: bzip, flate, gzip, lzw 和 zlib.

# 2. 写文件

1. 除了文件句柄，还需要 bufio 的 writer .

   • 以只读模式打开文件 output.dat , 文件不存在则自动创建
   • OpenFile 函数有三个参数：文件名，一个或多个标志 (使用逻辑运算符 "|" 连接), 使用的文件权限
   • os.O_RDONLY : 只读
   • os.O_WRONLY : 只写
   • os.O_CREATE : 创建，如果指定文件不存在，就创建该文件.
   • os.O_TRUNC : 截断，如果指定文件已存在，就该文件长度截为 0
   • 读文件时，文件的权限是被忽略的，所以使用 OpenFile 时传入的第三个参数可以用 0.
   • 写文件时，不论是 Unix 还是 Windowx 都需要使用 0666

   	outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
   	// 创建一个写入器 (缓冲区) 对象
   	outputWriter := bufio.NewWriter(outputFile)
   	// 将字符写入缓冲区
   	outputWriter.WriteString(outputString)
   	// 缓冲区的内容完全写入文件
   	outputWriter.Flush()
   	/*
   	* 写入简单内容时，使用 fmt.Fprintf 直接将内容写入文件
   	* fmt 包中 F 开头的 Print 函数可以直接写入任何 io.Writer, 包括文件
   	*/
   	fmt.Fprintf(outputFile, "Some test data.\n")

   • os.Stdout.WriteString("hello, world\n") 输出内容到屏幕
   • f, _ := os.OpenFile("test",os.O_CREATE|os.O_WRONLY,0666) 以只写模式创建或打开文件
   • f.WriteString() 不使用缓冲区，直接将内容写入文件

2. 文件拷贝

• 拷贝一个文件到另一个文件，最简单的方式就是使用 io 包
• defer , 当打开文件时发送错误， defer 仍然能够确保 src.Close() 执行，如果不关闭 src 文件会一直保持打开占用资源

func main() {

	CopyFile("copy","17.jpg")

	fmt.Println("Copy done!")

}

func CopyFile(dstName, srcName string) (written int64, err error) {

	src, err := os.Open(srcName)

	if err != nil {

		return

	}

	defer src.Close()

	dst, err := os.Create(dstName)

	if err != nil {

		return

	}

	defer dst.Close()

	return io.Copy(dst,src)

}

# 3. 从命令行读取参数

1. os 包中有一个 string 类型的切片变量 os.Args , 用来处理一些基本的命令行参数，它在程序启动后读取命令行输入的参数
   • 命令行参数会放置在切片 os.Args [] 中 (以空格分隔), 从索引 1 开始 ( os.Args[0] 放的是程序本身的名字)

func main() {

	who := "Alice "

	if len(os.Args) > 1 {

		who += strings.Join(os.Args[1:]," ")

	}

	fmt.Println("Good Morning",who)

}

2. flag 包中有一个扩展功能来解析命令行选项，但是通常被用来替换基本常量，例如，某些情况下给常量一些不一样的值

flag 包中有一个 Flag 被定义成含有如下字段的结构体:

typr Flag struct {

    Name 	string			// name as it appears on command line

    Usage	string			// help message

    Value	Value			// value as set

    DefValue	string		// default value (as text); for usage message

}

模拟 Unix 的 echo 功能

• flag.Parse() 扫描参数列表 并设置 flag ,
• flag.Arg(i) , 表示第 i 个参数. Parse() 之后 flag.Arg(i) 全部可用， flag.Arg(0) 就是第一个真实的 flag
• flag.Narg() 返回参数的数量。解析后 flag 或常量就可以使用
• flag.PrintDefaults() 打印 flag 的使用帮助信息
• flag.VisitAll(fn func(*Flag)) : 按照字典顺序遍历 flag , 并对每个标签调用 fn
• flag 定义类型 : flag.Bool() , flag.Int() , flag.Float64 , flag.String()

var NewLine = flag.Bool("n", false, "print newline") // echo -n flag, of type *bool

const (

    Space   = " "

    Newline = "\n"

)

func main() {

    flag.PrintDefaults()

    flag.Parse() // Scans the arg list and sets up flags

    var s string = ""

    for i := 0; i < flag.NArg(); i++ {

        if i > 0 {

            s += " "

            if *NewLine { // -n is parsed, flag becomes true

                s += Newline

            }

        }

        s += flag.Arg(i)

    }

    os.Stdout.WriteString(s)

}

# 4. buffer 读取文件

结合使用缓冲读取文件和命令行 flag 解析，输出内容

• 不添加参数时，cmd 输入什么就输出什么
• 参数是文件名时，如果文件存在就打印文件内容到屏幕，

func cat(r *bufio.Reader) {

    for {

        buf, err := r.ReadBytes('\n')

        fmt.Fprintf(os.Stdout, "%s", buf)

        if err == io.EOF {

            break

        }

    }

    return

}

func bufRead() {

    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.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())

            continue

        }

        cat(bufio.NewReader(f))

        f.Close()

    }

}

# 5. 切片读写文件

切片提供了 Go 中处理 I/O 缓冲的标准方式，

如下 cat 函数中，在一个切片缓冲内使用无限 for 循环 (直到文件尾部 EOF) 读取文件，并写入到标准输出 ( os.Stdout )

func cat(f *os.File) {

    const NBUF = 512

    var buf [NBUF]byte

    for {

        switch nr,err := f.Read(buf[:]); {

            case nr < 0: 

            	fmt.Fprintf(os.Stderr,"cat: error reading: %s\n",err.Error())

            	os.Exit(1)

            case nr == 0: //EOF

            	return

            case nr >0: 

            if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {

                fmt.Fprintf(os.Stderr,"cat: error writing: %s\n",ew.Error())

            }

        }

    }

}

# 6. defer 关闭文件

defer 关键字，对于函数结束时关闭打开的文件非常有用 :

// 在函数 return 后执行 f.Close () 关闭打开的文件

func data(name string) string {

    f, _ := os.OpenFile(name, os.O_RDONLY, 0)

    defer f.Close() //return 后关闭文件

    centos, _ := ioutil.ReadAll(f)

    return string(contents)

}

# 7. 接口使用实际案例: fmt.Fprintf

程序 io_interfaces.go 阐述了 io 包的接口概念

func main() {

    // unbuffered

    fmt.Fprintf(os.Stdout, "%s\n", "hello world! - unbuffered")

    // buffered: os.Stdout implements io.Writer

    buf := bufio.NewWriter(os.Stdout)

    // and now so does buf.

    fmt.Fprintf(buf, "%s\n", "hello world! - buffered")

    buf.Flush()  //Flush 方法将缓冲中的数据写入下层的 io.Writer 接口。

}

fmt.Fprintf() 函数的实际签名 :

• fmt.Fprintf() 依据指定的格式向第一个参数内写入字符串，参数一必须实现了 io.Writer 接口
• Fprintf() 能够写入任何类型，只要其实现了 write 方法，包括 os.Stdout , 文件 (如: os.File), 管道，网络，连接，通道等等.
• 同样也可以使用 bufio 包中缓冲写入. bufio 包中定义了 type Writer struct{...}
• 工厂函数 func NewWriter(wr io.Writer) (b *Writer) : 传递一个 io.Writer 类型参数，返回一个带缓冲的
• 其适合任何形式的缓冲读写，缓冲读写最后要使用 Flush() , 否则最后的输出不会被写入

func Fprintf(w io.Writer, format string, a ...interface{}) (n int,err error)

// 其参数不是写入一个文件，而是写入一个 io.Writer 接口类型的变量

type Writer interface {

    Write(p []byte) (n int,err error)

}

//bufio.Writer 实现了 Write 方法:

func (b *Writer) Write(p []byte) (nn int,err error)

# 8. JSON 数据格式

1. 数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在多种编码格式: JSON,XML,gob,Goole 缓冲协议，等等.Go 语言支持这些所有的编码格式

2. 结构可能包含二进制数据，如果将其作为文本打印，可读性很差，结构内部可能包含匿名字段，而不清楚数据的用意.

3. 通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据可以通过网络传输，而且与平台无关，任何类型的应用都能够读取和输出，不与操作系统和编程语言的类型相关.

4. 序列化是在内存中把数据转换成指定格式 (data -> string), 反之亦然 (string -> data structure)

5. 编码是输出一个数据流 (实现了 io.Writer 接口); 解码是从一个数据流 (实现了 io.Reader) 输出到一个数据结构.

   • 数据结构 --> 指定格式 = 序列化 或 编码 (传输之前)
   • 指定格式 --> 数据格式 = 反序列化 或 解码 (传输之后)

6. XML 被广泛的应用，但是 JSON 更加简洁、轻量 (占用更少的内存、磁盘及网络带宽) 和更好的可读性

encoding/json

6. JSON 与 Go 类型对应如下:

   • bool 对应 Json 的 boolean
   • float64 对应 JSON 的 Number
   • string 对应 JSON 的 string
   • nil 对应 JSON 的 null

7. 不是所有的数据都可以编码为 JSON 类型，只有验证通过的数据结构才能被编码:

   • JSON 对象只支持字符串类型的 Key; 编码 Go map 类型，map 必须是 map [string] T (T 是 json 包中支持的任何类型)
   • Channel, 复杂类型和函数类型不能被编码
   • 不支持循环数据结构；会引起序列化进入一个无限循环
   • 指针可以被编码，实际上是对指针指向的值进行编码 (或者指针是 nil)

8. 反序列化

   • func Unmarshal(data []byte,v interface{}) error 把 JSON 解码为数据结构

   • 对 JSON 数据进行解码时，首先创建结构体用来保存解码的数据:

     var v struct 并调用 json.Unmarshal(jsonData,&v)

   • 解析 []byte 中的 JSON 数据并将结果存入指针 &v 指向的地址

   • 虽然反射能够让 JSON 字段尝试匹配目标结构字段；但是只有真正匹配上次啊会填充数据，没有匹配到直接忽略

9. 解码任意数据

   • json 包使用 map[string]interface{} 和 []interface 存储任意的 JSON 对象和数组；其可以被反序列化为任何的 JSON blob 存储到接口值中

   	// 将 JSON 数据存储在变量 b 中
   	b := []byte(`{"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]}`)
   	// 无需了解这个数据结构，可以直接使用 Unmarshal 将数据保存在接口值中
   	var f interface{}
   	err := json.Unmarshal{b,&f}
   	//f 指向的是一个 map,key 是一个字符串，value 是自身存储作为空接口类型的值
   	map[string]interface{} {
   	"Name": "Wednesday",
   	"Age": 6,
   	"Parents": []interface{} {
   	"Gomez",
   	"Morticia",
   	},
   	}
   	// 访问这个数据可以使用类型断言
   	m := f.(map[string]interface{})
   	/*
   	* 通过 for range 语法和 typeswitch 来访问其实际类型
   	* 通过这种方式，可以处理位置的 JOSN 数据，同时确保类型安全
   	*/
   	for k, v := range m {
   	switch vv := v.(type) {
   	case string:
   	fmt.Println(k, "is string", vv)
   	case int:
   	fmt.Println(k, "is int", vv)
   	case []interface{}:
   	fmt.Println(k, "is an array:")
   	for i, u := range vv {
   	fmt.Println(i, u)
   	}
   	default:
   	fmt.Println(k, "is of a type I don’t know how to handle")
   	}
   	}

   • 如果事先已知 JSON 数据类型，可以定义一个适当的结构并对 JSON 数据反序列化.

   	// 定义接收数据的结构体
   	typr FamilyMember struct {
   	Name string
   	Age int
   	Parents []string
   	}
   	// 反序列化 JSON 数据
   	var m FamilyMember
   	err := josn.Unmarshal(b, &m)

10. 编码和解码流

• json 包提供 Decoder 和 Encoder 类型来支持常用 JSON 数据流读写. NewDecoder 和 NewEncoder 函数分别封装了 io.Reader 和 io.Writer 接口.

func NewDecoder(r io.Reader) *Decoder

func NewEncoder(w io.Writer) *Encoder

• 将 JSON 直接写入文件，可以使用 json.NewEncoder 初始化文件 (或者任何实现 io.Writer 的类型), 并调用 Encode (); 与之相应的是使用 json.NewDecoder 和 Decode () 函数

func NewDecoder(r io.Reader) *Decoder

func (dec *Decoder) Decode(v interface{})

# 9.XML 数据格式

• 如同 JSON 包一样，XML 也有 Marshal() 和 UnMarshal() 从 XML 中编码和解码数据；但其可以从文件中读取和写入
• 同 JSON 的方式一样，XML 数据也可以序列化为结构，或者从结构反序列化为 XML 数据
• xml 包定义了若干 XML 标签类型: StartElement, Chardata (从开始标签到结束标签之间的文本),EndElement, Comment, Directive 或 Proclnst
• xml 包中同样定义了一个结构解析器: NewParser 方法持有一个 io.Reader 并生成一个解析器对象，还有一个 Token() 方法返回输入流的下一个 XML token . 在输入流结尾处会返回 (nil, io.EOF)
• XML 文本被循环处理直到 Token() 返回一个错误，因为到达文件尾部，通过 type-switch 可以根据 XML 标签进一步处理. Chardata 中的内容是一个 []byte , 通过字符串转换让其可读性变得更强

# 10.Gob 传输数据

• Gob 是 Go 以二进制形式序列化和反序列化程序数据的格式
• Gob 特定地用于纯 Go 的环境中，两个用 GO 写的服务器之间通信更加高效和优化
• Gob 只有可导出的字段会被编码，零值会被忽略。在解码结构体是，只有同时匹配名称和可兼容型的字段才会被解码

# 11.Go 数据加密

• 网络传输的数据必须加密，防止被 hacker (黑客) 读取或篡改，并且保证发出的数据和接收到的数据校验和一致.
• has 包：实现了 adler32 , crc32 , crc64 和 fnv 校验；
• crypto 包：实现了其它 hash 算法，例如 md4 , md5 , sha1 等。以及完整实现 aes , blowfish , rc4 , rsa , xtea 等加密算法.
• 通过调用 sha1.New() 创建了一个新的 hash.Hash对象 ，用来计算 SHA1 校验值. Hash 类型实际上是实现了 io.Writer 的接口
• 通过 io.WriteString 或 hasher.Write 将给定的 []byte 附加到当前的 hash.Hash 对象中

func main() {

    hasher := sha1.New()

    io.WriteString(hasher, "test")

    b := []byte{}

    fmt.Printf("Result: %x\n", hasher.Sum(b))

    fmt.Printf("Result: %d\n", hasher.Sum(b))

    //

    hasher.Reset()

    data := []byte("We shall overcome!")

    n, err := hasher.Write(data)

    if n!=len(data) || err!=nil {