如何查看Go官网的文档？

在安装有Go的计算机命令行下使用godoc -http=:6060就可以通过localhost:6060访问Go官方文档。
也可以访问golang.google.cn不需出墙保卫长城。

什么是Go？

一个提供并发支持、垃圾回收的编译型语言，兼有静态编译语言的高性能和动态语言的高效开发（Go的编译速度快）的优势。
Go的主要特性：

• 类型安全（类型简单，有int string等内置类型，也有用户自定义类型，使用组合的方式就能复用类型的所有功能，避免传统面向对象继承模型的繁琐）和内存安全（语言自带垃圾回收器，不需要用户自己管理内存，垃圾回收增加了一些额外的开销但能显著降低开发难度）
• 以非常直观且代价极低的方式实现高并发，goroutine很像线程，但占内存更少，Go的并发模型是让数据在多个goroutine之间通过通道chanel传递，而不是多个goroutine争夺统一数据使用权。
• 高效的垃圾回收机制
• 快速编译
• 为多核计算机提供性能提升方案（能够指定使用多少个核）
• UTF-8编码的支持，避免乱码

Windows下安装Go的步骤？

• 1.下载msi文件，点击安装，安装程序会自动设置好GOROOT（Go安装目录）、GOTOOLDIR(工具目录)等环境变量，但是GOPATH环境变量（系统变量）需要自己手动配置
• GOPATH环境变量是Go程序的开发目录，也就是用户的工作目录，GOPATH下有多个工作目录的话在设置系统变量的时候可以用分号;分隔多个目录。根据约定需要在GOPATH的工作目录下建立三个独立文件夹，分别是：bin(存放编译后的二进制可执行文件)、pkg（用于存放编译好的包文件，文件拓展名为.a）、src（存放go源码文件）

Go语言常用的命令（在命令行或终端输入go可查看所有go命令）

go get: 获取远程包，需要提前安装git或者hg（从google code上获取远程包时使用）
go run:直接运行程序
go build:测试编译，检查是否有编译错误，编译当前目录下package为main的文件时会生成对应的可执行文件。package不是main的源码文件是包的源码文件，使用go build不会生成可执行文件。
go install: 先编译包文件后编译整个程序（主程序），包编译后的文件放到pkg目录下，编译得到的可执行文件放到bin目录下。 如果编译到bin目录下记得把可执行文件拷贝到项目文件根目录下，因为在项目各文件中我们一般使用相对路径，为了避免执行错误要把.exe文件拷贝回来
go fmt:格式化源码，所有的go源码都需保存为相同格式，保证格式的统一，一些IDE保存时会自动调用该命令
go doc:查看文档，多用godoc在浏览器中查看
go test:运行测试文件（运行当前目录下已_test.go结尾的文件）

Go编程基础

Go内置的25个关键字（均为小写）：

Go的注释方法与C++一致

Go程序的一般结构:

• Go程序通过package来组织（与Python一致）
• 只有package名称为main的包能包含main函数
• 一个可执行程序有且只有一个main包
• 通过关键字import来导入其他非main的包
• 导入的包必须使用，否则编译不通过
• 通过关键字const来定义常量
• 通过在函数体外部使用var关键字来声明和赋值全局变量
• 通过type关键字来声明结构struct或者接口interface
• 通过func关键字来声明函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// 当前程序的包名
package main

// 导入其他的包
import "fmt"

// 为包起别名，适用于包之间名字非常相近易混淆等情况
import iAndO "fmt"

// 导入其他多个包的简化写法（也可以逐个import，类似Java），调用包中的函数使用<包名>.<函数名>的方式
import {
    "fmt"
    "io"
    "os"
    "strings"
    "time"
}

// 定义常量
const PI=3.14

// 定义常量组（多个常量）
const (
    PI=3.14
    const1="1"
    const2=2
)

/*只存在全局变量组，并没有局部变量组。只有声明多个常量、多个全局变量、多个一般类型（非接口，非结构）的时候可以使用组，声明多个局部变量只能只用并行方式*/

// 全局变量的声明与赋值
var name="John"

// 声明全局变量组
var (
    name2="peter"
    name3="nicole"
)

/* 一般类型声明  相当于C中的typedef，严格意义上并不能说numberType是int的别名，numberType其实是自定义类型，其底层数据结构与int相同，在进行类型转换时依然需要显式转换，但是byte、rune确实是uint8和int32的别名，可以相互进行转换*/
type numberType int

// 一般类型组
type (
     numberType int
     scoreType float32
     userType string
     idType byte
)

// 结构的声明
type myStruct struct{} // 大括号不能省略，与C语言结构体类似

// 接口的声明
type golang interface{} // 大括号同样不能省略，与Java等语言中的接口类似

// 由main函数作为程序的入口点启动
func main(){   // go 规定主函数没有返回值与参数
    fmt.Println("hello world,你好，世界")  // 中英文混合，体现go对utf-8编码的支持
}

// main包中的main函数是启动程序的两个必须要素

/* 省略调用：将包的别名取为一个.  在调用这个包中的函数或者类型时就可以省略<包名>. 直接使用
 类型或者函数名来调用。不推荐使用省略调用，因为会导致具体使用的类型或函数所属的包模糊，在源码查看的过程中会非常吃力*/

可见性规则：Go语言中，使用大小写来决定常量、变量、类型、接口、结构或者函数是否可以被外部包所调用，首字母小写即为private，首字母大写即为public

Go的基本类型：

rune、byte这些别名或者类型存在的原因，就是从类型定义层面就增加代码的可阅读性，rune类型一般就是用来处理Unicode相关的类型，而byte用来处理字节相关的类型

• 布尔型：bool -长度：1字节； -取值范围：true false； -注意事项：不可以用数字代表true或false
• 整型：int/uint -根据平台可能为32位或者64位
• 8位整型：int8/uint8 -长度：1字节 -取值范围：-128~127/0~255
• 16位整型：int16/uint16 -长度：2字节 -取值范围：-32768~32767/0~65535
• 32位整型：int32(rune)/uint32 -长度：4字节 -取值范围：-2^32/2~2^32/2-1或者/0~2^32-1
• 64位整型：int64/uint64 -长度：8字节 -取值范围：-2^64/2~2^64/2-1或者/0~2^64-1
• 字节型：byte（uint8别名）在Go中如果要使用C语言中的char类型，一般使用byte类型
• 浮点型：float32/float64 -长度：4/8字节 -小数位：精确到7/15小数位 （由于有32位和64位浮点型之分，就可以省去double类型）
• 复数：complex64/complex128 -长度：8/16字节
• 足够保存指针的32位或者64位（根据操作系统平台的类型决定）整型：uintpr
• 其他类型：array struct string
• 引用类型：slice map chan
• 接口类型：interface
• 函数类型：func 在Go语言中，函数是可以赋值给变量的，所以函数也是一种类型

类型的零值：类型的零值不等于空值，而是当变量被声明为某种类型之后的默认值，通常情况下值类型的默认值为0，bool为false，string为空字符串

math包中的math.maxInt32等可以查看类型的数值范围

类型的别名：

1
2
3
4
5
6
7
8

type {
    文本 string  // UTF-8的优势（只是演示，不提倡使用中文）
}
// 不一定要加{}，可以直接type MyFlag int这样设置类型别名  
/*严格意义上并不能说numberType是int的别名，numberType其实是自定义类型，其底层数据结构与int相同，在进行类型转换时依然需要显式转换，但是byte、rune确实是uint8和int32的别名，可以相互进行转换*/

var name 文本
name="你好哇"

Go中变量的声明与赋值：

单个变量的声明与赋值：

• 变量声明的格式： var <变量名称> <变量类型>
• 变量的赋值格式：<变量名称>=<表达式>
• 变量声明的同时赋值： var <变量名称> <变量类型> = <表达式>

  1 2 3 4 5 6 7 8 9 10 11

  var name string // 变量的声明 name="peter" // 变量的赋值 // 变量声明的同时赋值 var id int = 9527 // 声明变量并赋值时省略类型，类型由系统推断 var cardId = 6277 // 变量声明与赋值的最简写法，var关键字和类型都省略了，由系统推断 d := 456 // :代表了var关键字

多个变量的声明与赋值：

• 全局变量的声明可以使用var()组的方式简写
• 全局变量的声明不可以省略var，故不能使用:=的形式，但可以使用并行方式
• 所有变量都可以使用类型推断
• 局部变量不可以使用var()的方式简写，只能使用并行方式
• :=使用最广泛的是在获取函数返回值的时候
• 可以使用下划线对某一值进行忽略(是作为blank identifier空标识符)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var{
    // 使用常规方式
    aaa = "hello"
    
    // 使用并行方式及类型推断
    sss,bbb=1,2   
}

func main(){
    var a,b,c,d int=1,2,3,4  // 并行方式声明多个局部变量
    var a,b,c,d =1,2,3,4 // 也正确
    a,b,c,d :=1,2,3,4  // 也正确
    
    var e,_,g=7,8,9  // 8的值被忽略，多用于:=来获取函数返回值时，某一返回值暂不需要使用，可以忽略的情况
}

变量的类型转换：

• Go中不存在隐式转换，所有类型类型转换必须显式声明 （保证了Go的类型安全特性）
• 转换只能发生在两种相互兼容的类型之间
• 类型转换的格式： [:]= () [:]表示:可以省略，根据valueA是否需要声明来决定是否省略

1
2
3
4
5
6
7

// 在相互兼容的两种类型之间进行转换
var a float32 = 1.1
b := int(a)  // 存在精度的丢失但是两种类型之间是相互兼容的

// 以下语句无法通过编译，因为不是两种相互兼容的类型间的转换
var c bool = true
d := int(c)  // 在Go中逻辑型变量与数值型变量之间不兼容

解释下面程序的结果：

1
2
3
4
5
6

func main() {
	var temp int = 65
	b := string(temp)
	fmt.Println(b) // 结果是A，整型转换为字符串时，转换的结果是整型在ASCII码表中对应的字符
	// 如果要转换成对应的字符，可以增加一个包strconv，然后使用strconv.Itoa 将string转换成数字使用strconv.Atoi
}

Go中常量的声明与赋值：

常量的定义：

• 常量的值在编译的时候就已经确定
• 常量的定义格式与变量基本相同
• 等号右侧必须是常量或者常量表达式(因为常量的值在编译时就确定，在运行时才确定的表达式的值就不满足要求，会编译报错)
• 常量表达式中的函数必须是内置函数（因为只有内置函数在编译时才是确定的）

1
2
3
4
5
6
7
8
9
10
11
12
13

// 定义单个常量
const a int = 1
const b = 'a'
const (
    c = a
    text = "123"
    length = len(text)  // len()是一个函数
    num = a*20
    d,e,f=1,2,3
)

// 也可以像定义变量一样定义常量
const a,b,c=1,"2",'c'

常量组初始化规则，在定义常量组时，如果不提供初始值，则表示将使用上行的表达式：

1
2
3
4
5
6
7
8
9
10

const (
	a = 1
	b = 'e'
	c
)

func main() {
	fmt.Println(c) // 输出结果101，是'e'的ASCII码值
	// 即当常量组里有没有初始化的常量时，则编译器使用上一行的表达式来对它进行初始化，即执行c='e'
}

1
2
3
4
5
6
7
8

const (
	a,b = 1,2
	c   // 编译不通过
)

func main() {
	fmt.Println(c) 
}

1
2
3
4
5
6
7
8

const (
	a,b = 1,2
	c,d   // 编译通过，c为1，d为2
)

func main() {
	fmt.Println(c) 
}

定义常量时等号右侧必须是常量或者常量表达式的经典例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package main

import (
	"fmt"
)

var val = "arrive" // 全局变量

const (
	a = len(val)  
	// 运行时会报错：const initializer len(val) is not a constant，因为编译的时候并不存在一个字符串叫val
	b = 'e'
)

func main() {
	fmt.Println(a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package main

import (
	"fmt"
)

const (
    val = "arrive"
	a = len(val)  // 可以编译通过并运行
	b = 'e'
)

func main() {
	fmt.Println(a)
}

常量初始化规则与枚举

• 在定义常量组时，如果不提供初始值，则使用上一行的表达式对其赋值
• 使用相同的表达式不代表具有相同的值
• iota是常量计数器，从0开始，组中每定义1个常量自动递增1
• 通过初始化规则与iota可以达到枚举的效果
• 每遇到一个const关键字，iota就会重置为0

1
2
3
4
5
6
7
8
9
10
11

const {
    a = "A"
    b
    c = iota  // c的值为2
    d  // d的值为3,套用上一行的表达式   即实际上执行了d=iota
}

const {
    e = iota
    f // f的值为1
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 星期枚举
const{
    // 第一个常量不可省略表达式
    MONDAY = iota
    TUESDAY
    WEDNESDAY
    THURSDAY
    FRIDAY
    SATURDAY
    SUNDAY
    
    // 由于常量取名时一般都是全部字母大写（可配合下划线），这样会导致常量都可以被外部
    // 的包调用，如果不想常量被外部的包调用的话，可以在常量名前加下划线或小写字母c，如
    // _MONDAY cMONDAY
}

Go中的运算符：

Go中的运算符都是从左向右结合

优先级从高到低依次为：

1
2
3
4
5
6
7

-   ^(^x一元运算符,bitwise complement  or bitwise not按位取反)   !  
-   *     /     %       <<      >>      &^(bit clear (AND NOT)将右边操作数先按位取反^，再和左边操作数进行按位与&运算)
-   |       ^(二元运算符XOR)
-   ==      !=      <       <=      >=      >
-   <-  (专门用于channel)
-   && 
-   ||

思考：请尝试结合常量的iota与<<运算符实现计算机存储单位的枚举？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

type ByteSize float64
const (
	BIT ByteSize = 1 << (iota * 10)
	KB
	MB
	GB
	TB
	PB
	EB
	ZB
	YB
)

func main() {
	fmt.Println(KB)
}

Go中的指针：

Go保留了指针，与其他编程语言例如C语言不通的是，在Go中不支持指针运算以及->运算符，而直接采用.运算符来操作指针对象的成员

• 操作符&取变量的地址，使用*通过指针间接访问目标对象
• 指针默认值为nil而不是null

1
2
3
4

func main() {
	var p *int
	fmt.Println(p)   // 输出的结果是<nil>
}

Go中，++ –是作为语句而不是作为表达式，两者的区别是表达式是可以放在等号右边的，而语句是不可以放在等号右边的，只能作为单独的语句：

1
2
3
4
5
6

func main() {
	a:=1
	a = a++  // 编译不通过：syntax error: unexpected ++ at end of statement
	// Go中只有后自增和后自减，没有前自增和前自减
	fmt.Println(a)
}

Go中的控制语句：

if控制语句：

• 条件表达式没有括号
• 支持一个初始化表达式（可以采用并行方式初始化多个变量）
• Go中if控制语句的左大括号必须和条件语句或者else同一行 （严格定义了代码书写的规范）
• 支持单行模式
• 初始化语句中的变量为block级别，同时隐藏外部同名变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
	a := true
	if a, b, c := 1, 2, 3; a+b+c > 6 {
		fmt.Println("大于6")
	} else {
		fmt.Println("小于等于6")
		fmt.Println(a)
	}
	fmt.Println(a)
	// 运行结果：
	//	小于等于6
	//	1
	//	true
}

for循环语句：

• Go语言中只有一个for循环语句关键字，但支持三种形式，简洁高效
• 初始化和步进表达式可以是多个值
• 条件语句每次循环都会被重新检查，因此不建议在条件语句中使用函数，尽量提前计算好条件并以变量或者常量代替，避免在循环中频繁调用函数导致程序性能骤降
• 左大括号必须和条件语句在同一行

1
2
3
4
5
6
7
8
9
10
11

// 无限循环形式
func main() {
	a := 1
	for {
		a++
		if a > 3 {
			break
		}
	}
	fmt.Println(a)
}

1
2
3
4
5
6
7
8

// 类似while循环结构的形式
func main() {
	a := 1
	for a <= 3 {
		a++
	}
	fmt.Println(a)
}

1
2
3
4
5
6
7
8

// for经典形式
func main() {
	a := 1
	for i := 0; i < 3; i++ {
		a++
	}
	fmt.Println(a)
}

选择语句switch：

• 可以使用任何类型或者表达式作为条件语句
• 不需要写break，一旦条件符合自动终止
• 如希望继续执行下一个case，需使用fallthrough语句
• 支持一个初始化表达式（可以是并行方式），右侧需要跟分号
• 左大括号必须和条件语句在同一行

1
2
3
4
5
6
7
8
9
10
11

func main() {
	a := 1
	switch a {
	case 0:
		fmt.Println("a==0")
	case 1:
		fmt.Println("a==1")
	default:
		fmt.Println("none")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Go中的switch语句switch后的条件可以省略，case后面不仅仅可以写常量，也可以写表达式
// 如果省略switch后面的表达式，则直接根据case后面的表达式是否为真来判断是否执行case后的语句
// Go中的switch执行完一个case之后直接跳出switch，不需要使用break，可以使用fallthrough来继续执行
// 下一个case
func main() {
	switch {
	case 0 == 0:
		fmt.Println("a==0")   // 执行结果为 a==0
	case 1 == 1:
		fmt.Println("a==1")
	default:
		fmt.Println("none")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
	switch {
	case 0 == 0:
		fmt.Println("a==0")
		fallthrough
	case 1 == 1:
		fmt.Println("a==1")
	default:
		fmt.Println("none")
	}
}
// 执行结果：
//	a==0
//	a==1

1
2
3
4
5
6
7
8
9
10
11
12
13

func main() {
	switch a := 1; {
	case a == 0:
		fmt.Println("a==0")
		fallthrough
	case a == 1:
		fmt.Println("a==1")
	default:
		fmt.Println("none")
	}
}
// 执行结果
// a==1

Go语言中的跳转语句goto,break,continue：

• 三个都可以配合标签使用
• 标签名区分大小写，若不使用会造成编译错误
• break与continue配合标签可以用于多层循环的跳出，跳出的循环是与标签同级的循环
• goto是调整执行位置，与其它2个语句配合标签的结果并不相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
LABEL1:
	for i := 0; i < 3; i++ {
		for {
			break LABEL1
		}
		fmt.Println(i)
	}
	fmt.Println("ok")
}
// 执行结果：ok  因为直接跳出了与LABEL1同级的循环
// 如果将break换成continue，执行结果不变
// 如果将break换成goto，程序会发生死循环
// Tips：如果要使用goto语句，将标签写在goto语句后面会有效避免

Go中的数组Array：

• 定义数组的格式： var [n] , n>=0
• 数组长度也是类型的一部分，因此具有不同长度的数组是不同的类型
• 注意区分指向数组的指针和指针数组
• 数组在Go中为值类型，其它语言多将数组作为引用类型，值类型的意思是在Go中将数组作为函数的参数时，作为参数的数组会被拷贝，而不是直接引用这个数组（将地址传递给方法和函数）。数组的引用传递可以使用slice切片
• 数组之间可以使用==或者!=进行比较，但不能使用>和<。注意：长度不同的数组由于是不同的类型，故不可以使用==或者!=来进行比较，若使用会编译报错 元素的类型不同的数组当然也不能直接进行比较
• 可以使用new来创建数组，此方法返回一个指向数组的指针
• Go支持多维数组

1
2
3
4
5
6
7

func main() {
	var a [2]int
	var b [1]int
	a = b  // 编译报错：cannot use b (type [1]int) as type [2]int in assignment 
	// 不同长度的数组是不同的类型，故不能直接使用=赋值
	fmt.Println(a)
}

1
2
3
4
5
6

func main() {
	var a [2]int
	var b [2]int
	a = b  // 相同长度且元素是相同类型的数组是同种类型，可以直接使用=赋值
	fmt.Println(a)  // 输出结果[0 0]，输出了数组a的值（使用了int型的零值）
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

func main() {
	var a [2]int
	var b [2]int
	c := [2]int{1, 2}  // 可以使用类似变量定义的简写方式简写数组的定义，且该情况下可以使用{}进行数组初始化
	d := [10]int{9: 1} // 使用索引将下标为9的元素值赋为1
	e := [...]int{1, 2, 3, 4}  // 使用三个点来省略数组元素的个数，编译器由初始元素的个数自动分配数组的长度
	f := [...]int{19: 1}  // 编译器自动设置数组长度为20，且将下标为19的元素值设置为1
	a = b
	fmt.Println(a)
	fmt.Println(c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)
}
// 输出结果
// [0 0]
// [1 2]
// [0 0 0 0 0 0 0 0 0 1]
// [1 2 3 4]
// [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]

1
2
3
4
5
6

// 数组指针与指针数组
func main() {
	c := [2]int{1, 2}
	var p *[2]int = &c // p是数组指针，即指向数组的指针
	fmt.Println(p)     // 输出结果&[1 2]，意思是[1,2]这个数组的地址
}

1
2
3
4
5

func main() {
	x, y := 1, 2
	a := [...]*int{&x, &y} // a是指针数组，数组中的每个元素都是指针，两个元素分别是指向x和y的指针
	fmt.Println(a)         // 输出结果	[0xc04204e080 0xc04204e088]，是x和y两个值的地址
}

1
2
3
4
5
6
7
8
9
10
11
12
13

// 无论是数组本身，还是指向数组的指针，都可以使用[下标（索引）]的形式对数组中的单个元素进行操作
func main() {
	a := [3]int{}
	a[1] = 4
	p := new([3]int)  // 使用new定义数组返回的是一个数组指针
	p[1] = 4
	fmt.Println(a)
	fmt.Println(p)
}

//  输出结果：
//	[0 4 0]
//	&[0 4 0]

1
2
3
4
5
6
7
8
9
10
11

// Go中的多维数组的定义，形式类比c
func main() {
	a := [2][3]int{
		{1, 2, 3},
		{4, 5, 6}} // 多维数组元素初始化的最后这个有大括号必须跟在定义的最后，不能单独占一行
	b := [...][3]int{    // 多维数组的最后一维的大小不能省略
		{1: 1},   // 多维数组同样可以使用索引
		{2: 2}}
	fmt.Println(a) // 输出结果：[[1 2 3] [4 5 6]]
	fmt.Println(b) // 输出结果：[[0 1 0] [0 0 2]]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 小例子：数组的排序
func main() {
	a := [5]int{5, 4, 7, 9, 3}
	l := len(a) // 提前使用一个变量存储数组的长度，避免循环中反复调用len()函数导致程序性能下降
	for i := 0; i < l; i++ {
		for j := i + 1; j < l; j++ {
			if a[i] > a[j] {
				temp := a[i]
				a[i] = a[j]
				a[j] = temp
			}
		}
	}
	fmt.Println(a) // 输出结果：	[3 4 5 7 9]
}

Go中的slice切片：

• 本身并不是数组，它指向一个底层的数组
• slice是作为变长数组的替代方案（array是不可变长的），slice可以关联底层数组的局部或者全部
• 由于slice指向底层的数组，也就是slice是指针，故slice是引用类型
• slice可以直接创建或者从底层数组获取生成
• 使用len()获取元素个数（同array），使用cap()获取容量
• 一般使用make()函数创建slice，不使用new，因为new得到的是一个指针，而slice本身又是一个指针，用new就会得到指向指针的指针
• 如果多个slice指向相同底层数组，其中一个的值发生改变会影响全部
• make([]T, len, cap)
• 其中cap可以省略，省略则默认cap和len的值相同
• len表示存数的元素个数，cap表示容量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// slice的声明
func main() {
	// 直接声明一个slice
	var s1 []int // []中没有...也没有数字就是声明了一个slice

	// 截取数组的一部分构成一个slice
	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
	s2 := a[9]    // 截取下标为9的一个元素
	s3 := a[5:10] // 从下标为5的元素开始截取多个元素  [5,10)左闭右开
	s4 := a[5:len(a)]
	s5 := a[5:] // 从下标为5的元素开始，一直取到数组的尾部
	s6 := a[:5] // 从首部开始，一直取到数组的首部

	// 使用make函数声明数组
	s7 := make([]int, 3, 10)
	fmt.Println("定义一个空slice s1:", s1)
	fmt.Println("截取数组中的一个元素得到值s2:", s2)
	fmt.Println("截取数组的后5个元素 s3:", s3)
	fmt.Println("同上，使用len()帮助截取 s4:", s4, "len:", len(s4), "cap:", cap(s4))
	fmt.Println("s5:", s5, "len:", len(s5), "cap:", cap(s5))
	fmt.Println("s6:", s6, "len:", len(s6), "cap:", cap(s6))
	fmt.Println("s7:", s7, "len:", len(s7), "cap:", cap(s7))

	b := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'}
	slice1 := b[2:6]
	fmt.Println("sclie1:", string(slice1), "len:", len(slice1), "cap:", cap(slice1), "需要注意，截取数组的一部分作为切片的时候，切片的容量是从截取的元素开始直到数组末的元素个数")

	// reslice 截取切片的一部分作为切片
	slice2 := slice1[1:3]
	fmt.Println("sclie1:", string(slice2), "len:", len(slice2), "cap:", cap(slice2))
}

/* 运行结果
定义一个空slice s1: []
	截取数组中的一个元素得到值s2: 0
	截取数组的后5个元素 s3: [6 7 8 9 0]
	同上，使用len()帮助截取 s4: [6 7 8 9 0] len: 5 cap: 5
	s5: [6 7 8 9 0] len: 5 cap: 5
	s6: [1 2 3 4 5] len: 5 cap: 10
	s7: [0 0 0] len: 3 cap: 10
	sclie1: cdef len: 4 cap: 9 需要注意，截取数组的一部分作为切片的时候，切片的容量是从截取的元素开始直到数组末的元素个数
	sclie1: de len: 2 cap: 8
*/

关于reslice：

• reslice时索引以被slice的切片为准，不再以原slice指向的数组为准
• 索引不可以超过被slice的切片的容量值
• 索引越界不会导致底层数组的重新分配，而是会导致错误

append函数:

• 可以在slice尾部追加元素
• 可以将一个slice追加在另一个slice尾部,相当于数组拼接的效果
• 如果最终长度未超过追加到的slice的容量则返回原始slice，不会重新分配数组空间
• 如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
	s1 := make([]int, 3, 6)
	fmt.Printf("%p\n", s1)
	s1 = append(s1, 1, 2, 3)
	fmt.Printf("%v %p\n", s1, s1)
	s1 = append(s1, 1, 2, 3)
	fmt.Printf("%v %p\n", s1, s1)
}

/* 运行结果：
    0xc04206a030
	[0 0 0 1 2 3] 0xc04206a030
	[0 0 0 1 2 3 1 2 3] 0xc0420400c0  注意此时s1的地址发生了改变，因为超出容量会重新分配一个数组
*/

1
2
3
4
5
6
7
8
9
10
11
12
13

func main() {
	a := []int{1, 2, 3, 4, 5}
	s1 := a[2:5]
	s2 := a[1:3]
	fmt.Println(s1, s2)
	s1[0] = 9
	fmt.Println(s1, s2)
}

/* 运行结果：   
    [3 4 5] [2 3]
	[9 4 5] [2 9]   多个slice指向同一个数组，其中一个改变，另外的也会跟着改变
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func main() {
	a := []int{1, 2, 3, 4, 5}
	s1 := a[2:5]
	s2 := a[1:3]
	fmt.Println(s1, s2)
	s2 = append(s2, 6, 7, 8, 9, 4, 3, 2, 2, 1, 4)
	s1[0] = 9
	fmt.Println(s1, s2)
}

/* 运行结果：   
    [3 4 5] [2 3]
	[9 4 5] [2 3 6 7 8 9 4 3 2 2 1 4]  
	append超出原数组容量，重新分配了一个数组用于存储s2，故s1的改变不会导致s2的改变
*/

copy函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

func main() {
	s1 := []int{1, 2, 3, 4, 5} // []内没有...表明是切片而不是数组
	s2 := []int{7, 8, 9}
	copy(s1, s2) // 将s2拷贝至s1中
	fmt.Println(s1)
	fmt.Println(s2)
	s3 := []int{1, 2, 3, 4, 5} // []内没有...表明是切片而不是数组
	s4 := []int{7, 8, 9}
	copy(s4, s3) // 将s3拷贝至s4中
	fmt.Println(s3)
	fmt.Println(s4)

	// 使用索引的方式进行copy
	copy(s4[0:2], s3[2:4])
	fmt.Println(s3)
	fmt.Println(s4)
}
/* 运行结果：
	[7 8 9 4 5]
	[7 8 9]
	[1 2 3 4 5]
	[1 2 3]
	[1 2 3 4 5]
	[3 4 3]
*/

Go中的map：

• 类似其他语言中的哈希表或者字典，以key-value形式存储数据
• key必须是支持==或者!=比较运算符的类型，不可是函数、map或者slice，int、string、byte类型的数据都是可以使用比较运算符的
• Map查找比线性搜索快得多，但比使用索引访问数据慢100倍
• Map使用make()创建，支持:=的简写创建方式
• make(map[keyType]valueType,cap)，cap表示容量，可以省略
• 超出容量时会自动扩容，但尽量使用一个合理的初始值
• 使用len()函数获取元素个数
• 访问的键不存在时会自动添加该键，如类型为[int]string的map1中没有键1时执行代码map1[1]=hello,解释器会自动添加键1值为hello的键值对
• 使用delete()可以删除键值对
• 使用for range对map和slice进行迭代操作，类似于其他语言的for each，但是更加高级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

func main() {
	var m1 map[int]string = map[int]string{} // 使用map关键字创建一个map，如果省略这里的{}，会导致编译type map[int]string is not an expression错误

	var m2 map[int]string // 也可以分开写，声明和实例化分开      map[int]string这个整体是一种类型，声明map和声明变量的格式本质上是一致的
	m2 = map[int]string{}

	fmt.Println(m1) // 运行结果：map[]
	fmt.Println(m2) // 运行结果：map[]

	// 省略声明的类型
	var m3 = map[int]string{} // 实例化的大括号不能少
	fmt.Println(m3)           // 运行结果：map[]

	// 使用make函数创建map，使用make函数依然要使用map关键字
	var m4 = make(map[int]string, 10)
	fmt.Println("m4:", m4) //m4: map[]

	// 使用:=同时省略声明的类型和var关键字
	m5 := map[string]string{}
	fmt.Println(m5) // 运行结果：map[]

	// 向map中添加元素
	m1[1] = "zhao" // 解释器会自动创建键值对
	m1[2] = "qian"
	m1[3] = "sun"
	fmt.Println(m1) // map[1:zhao 2:qian 3:sun]

	// 删除键值对,使用delete()函数
	delete(m1, 2)
	fmt.Println(m1) // map[1:zhao 3:sun]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 复杂map的操作
func main() {
	// 使用多个map嵌套的时候要注意每一级的map都要初始化（可以借助多返回值辅助判断是否初始化），如果没有初始化直接使用会导致运行时的错误，编译无法发现
	m1 := make(map[int]map[int]string, 10) // value的类型依然是一个map
	fmt.Println(m1)
	val, ok := m1[1][1]      // 使用Go中的多返回值，第一个返回值是获取的map中的元素，第二个返回值标记该元素所在的map是否存在的布尔值
	fmt.Println(m1, val, ok) // m1外层的map已经初始化，但是m1中作为值的内层的map没有经过初始化，所以ok为false
	if !ok {
		m1[1] = make(map[int]string, 10)
	}
	m1[1][1] = "hello"
	val, ok = m1[1][1]
	fmt.Println(m1, val, ok)

	/*
		map[]
		map[]  false
		map[1:map[1:hello]] hello true
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import (
	"fmt"
	"sort"   // 导入sort包用于排序
)

func main() {
	// 借助slice完成对map的间接排序
	m := map[int]string{1: "spring", 2: "dubbo", 3: "maven", 4: "mybatis", 5: "flask"}
	s := make([]int, len(m))
	i := 0
	for k, _ := range m {
		s[i] = k
		i++
	}
	fmt.Println(m, s)
	sort.Ints(s)
	fmt.Println(s)

	/*
		map[4:mybatis 5:flask 1:spring 2:dubbo 3:maven] [3 4 5 1 2]
		[1 2 3 4 5]
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func main() {
	// 使用for range将类型为map[int]string的键和值进行交换，变成类型为map[string]int
	m := map[int]string{1: "spring", 2: "dubbo", 3: "maven", 4: "mybatis", 5: "flask"}
	m2 := make(map[string]int, 5)
	for k, v := range m {
		m2[v] = k
	}
	fmt.Println(m)
	fmt.Println(m2)

	/*
		map[3:maven 4:mybatis 5:flask 1:spring 2:dubbo]
		map[spring:1 dubbo:2 maven:3 mybatis:4 flask:5]
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// slice的元素为map，如何进行初始化
func main() {
	s := make([]map[int]string, 3, 10)
	fmt.Println(s) // [map[] map[] map[]]

	/*s[1][1] = "hello"
	fmt.Println(s) // 运行会报 panic: assignment to entry in nil map的错误，因为slice中的map还没有被初始化*/

	// 使用for range对元素为map的slice进行初始化
	for i, _ := range s {
		s[i] = make(map[int]string, 10)
	}

	s[1][1] = "hello"
	fmt.Println(s) // [map[] map[1:hello] map[]]
}

Go中的函数function

• Go语言中的函数不支持嵌套、重载和默认参数
• Go中的函数支持以下特性：无需声明原型（C语言中存在函数之间的复杂调用要先声明一下函数的原型再使用函数）、不定长度变参、多返回值、命名返回值参数、匿名函数和闭包
• Go语言中的匿名函数不能作为顶级函数（最外层函数），只能作为内部函数存在其他函数中
• 定义函数使用关键字func，且左大括号不能另起一行
• 函数也可以作为一种类型使用

ps：什么是闭包closure-

一般程序中局部变量都会有一个作用范围scope，闭包就是持续存在的局部变量范围（A closure is a persistent local variable scope），让局部变量能够在正常的scope之外还能存在。那这个范围是多大呢？与绑定的函数的作用范围一致（The scope object, and all its local variables, are tied to the function, and will persist as long as that function persists.）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

 // 没有参数和返回值的函数
func func1() {

}

// 有两个int型参数的函数-原始写法
func add(a int, b int) {

}

// 有两个int型参数的简写
func add2(a, b int) {

}

// 有一个int型返回值的函数
func getSum(a, b int) int {
	return a + b
}

// 有多个返回值的函数
func getSumRight(a, b int) (int, bool) {
	return a + b, true
}

// 有多个相同类型的返回值，依然可以简写
func getSumReturnNums(a, b, c int) (sum, num1, num2, num3 int) { // 多个相同返回值简写时必须要写上返回的变量名，注意加上返回变量名之后函数在运行的时候就会存在相应的局部变量
	num1 = a
	num2 = b
	num3 = c
	return a + b + c, num1, num2, num3
}

// 不定长变参的使用方法
func variableIndefinite(name string, cardIds ...int) { // 注意不定长变参一定要作为函数最后一个参数
	fmt.Println(cardIds) // 调用variableIndefinite("zhe", 14, 13)时，输出结果为[14 13]，不定长度变参是使用slice来处理的，
	//						特别注意slice是引用类型,slice直接作为函数参数会拷贝slice这个指针（地址的拷贝），会导致外部值的变化，而使用不定长变参本质上是slice中值的拷贝，
	//																				在函数内对可变长参数进行修改不会导致外部值的变化
}

// 在函数内需要对非引用类型进行值的修改时：使用取地址符&和指针*的形式，与C语言中一致
func changeATo2(a *int) {
	*a = 2 // 主函数内 a :=1         changeATo2(&a)    能导致原始a的值的改变，其原因还是因为拷贝的地址，参数传递肯定会带来拷贝，区别就是拷贝的是地址还是值
	fmt.Println(*a)
}

// Go语言中函数也是类型的例子
func funcIsAlsoType() {
	fmt.Println("hello")
	// 主函数中执行下面的语句：
	// a:=funcIsAlsoType()
	// a()   // 运行结果为 hello，函数可以被赋值，此时a就相当于函数funcIsAlsoType，说明在Go中一切皆类型的思想
}

// Go中的匿名函数
func main() {
	a := func() {
		fmt.Println("hello")
	}
	a() // 也能输出hello,此处就是定义了一个匿名函数，=赋值符号右边的函数没有名称，将等号右边的这个没有名字的函数作为一个函数类型赋值给了a，导致a是这一种类型的一个变量
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Go中的闭包
func main() {
	f := closure(10)
	fmt.Println(f(0))
	fmt.Println(f(1))
	fmt.Println(f(2))

	/*	运行结果:   x的生命周期被延长
		0xc04204e090
		0xc04204e090
		10
		0xc04204e090
		11
		0xc04204e090
		12
	*/

}

func closure(x int) func(int) int {
	fmt.Printf("%p\n", &x)
	return func(y int) int {
		fmt.Printf("%p\n", &x)
		return x + y
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 附一段js的闭包例子
outer = function() {
  var a = 1;
  var inner = function() {
    console.log(a);
  }
  return inner; // this returns a function
}

var fnc = outer(); // execute outer to get inner 
fnc();

/*
Here I have defined a function within a function. The inner function gains access to all the outer function's local variables, including a. The variable a is in scope for the inner function.

Normally when a function exits, all its local variables are blown away. However, if we return the inner function and assign it to a variable fnc, so that it persists after outer has exited, all of the variables that were in scope when inner was defined also persist. The variable a has been closed over -- it is within a closure.

Note that the variable a is totally private to fnc. This is a way of creating private variables in a functional programming language such as JavaScript.
*/

Go中的defer关键字

• defer的执行方式类似其他语言中的析构函数，在函数体执行结束后按照调用顺序的相反顺序逐个执行
• 即使函数发生严重错误也会执行
• 支持匿名函数的调用
• 常用于资源清理、文件关闭、解锁以及记录时间等操作，先定义的defer函数会最后执行，后定义的defer函数会最先执行
• 通过与匿名函数配合可在return之后修改函数计算结果
• 如果函数体内某个变量作为defer时匿名函数的参数，则在定义defer时即已经获得了拷贝，否则则是引用某个变量的地址 类似闭包
• Go没有异常机制（没有try
  catch捕获机制，但有类似finally最终无论如何都要执行的语句），Go中使用panic()/recover()模式来处理错误。具体做法是利用Go中多返回值的特性来得到error类型的返回，在调用这个函数之后进行check(借助defer，因为程序发生panic之后正常的函数都会停止执行，只有defer不管程序是否发生错误它都会执行)，check一下error是否等于nil，不为nil就是发生了错误，以此来判断函数在运行过程中是否发生了错误。
• 含有recover的defer函数必须要在recover对应处理的panic之前注册，否则该recover无效
• Panic可以在任何地方引发，但recover只有在defer调用的函数中有效

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
    // 直接打印i的值 前面加defer
	for i := 0; i < 3; i++ {
		defer fmt.Println(i)
	}

	/*	运行结果: defer调用是栈的一个结构，先进后出
		2
		1
		0
		
		i是作为一个参数传进来，是一个值传递
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

func main() {
	// 将打印i的值的语句放在匿名函数中，前面加defer
	for i := 0; i < 3; i++ {
		defer func() {
			fmt.Println(i)
		}()
	}

	/*	运行结果:
		3
		3
		3

		原因是这边相当于一个闭包，i是作为参数是使用的地址，i是作为地址的引用，当程序退出的时候i就变成了局部变量3
		当main函数return之后开始执行return语句，i就是一直引用的等于3的情况
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func main() {
	A()
	B()
	C()
}

func A() {
	fmt.Println("function A")
}

func B() {
	panic("Panic in B")
}

func C() {
	fmt.Println("function C")
}

/*	运行结果： 因为触发了panic，所以只执行到了B()函数程序就停止运行了
	function A

	panic: Panic in B

*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

func main() {
	// 通过recover()来恢复程序的执行
	A()
	B()
	C()
}

func A() {
	fmt.Println("function A")
}

func B() {
	defer func() { // 这里注意要把这个defer recover的函数写在panic前面，要先注册一下defer函数，否则先运行panic程序就会先退出了
		if err := recover(); err != nil { // 使用recover()对程序进行检测恢复，看程序是否引发了panic，recover()的返回值不是nil，则说明引发了panic，是nil说明没有引发panic
			fmt.Println("Recover in B")
		}
	}()
	panic("Panic in B")
}

func C() {
	fmt.Println("function C")
}

/*	运行结果：
	function A
	Recover in B
	function C

*/

Go中的结构struct：

• Go中的struct和C中的struct非常相似，而且Go没有class，结构承担了Go中面向对象的功能
• 使用type struct{}的方式定义结构，名称遵循可见性原则(大小写控制public或者private)
• 支持指向自身的指针成员，可以使用类似C语言中指针的形式来定义指向结构的指针，并且无论是指向结构的指针还是结构变量本身都可以使用.访问结构中的成员
• 支持匿名结构，可用作成员或定义成员变量。既可以有匿名成员变量（此时初始化的顺序要严格按照定义的顺序），也可以有匿名结构作为结构的成员（初始化一定要使用.的形式，不能用{}直接初始化的形式，因为无法得知匿名结构的名称）
• 匿名结构也可以用作map的值
• 可以使用字面值对结构进行初始化，也就是使用{}中加上值的形式直接进行初始化，不需要另外加上语句使用.来进行初始化
• 允许直接通过指针来读写结构体成员（同样的也是直接使用.，不像C中使用->，因为Go中没有指针运算，Go进行了优化可以直接使用.）
• 相同类型的成员可以直接进行赋值拷贝
• 支持==和!=比较运算符，但不支持<或>
• 支持匿名字段，本质上是定义了以某个类型名为名称的字段
• 嵌入结构作为匿名字段看上去像是继承但不是继承，Go中没有继承，使用组合模式作为替代
• 可以使用匿名字段指针

Go中的method：

• Go中没有class，但是依然有method，写method的形式和写函数类似，就是多了一个receiver接收者的概念，编译器根据receiver来判断该方法属于哪个结构struct
• 虽说Go中没有方法重载的概念，但是由于每一个方法都有绑定的receiver，所以不同receiver可以有相同名字的方法，这样就实现了类似重载的功能
• 通过显示说明receiver来实现与某个类型的组合
• 一个结构中的私有字段（首字母小写）可以被其绑定的方法访问，可见方法拥有较高的访问权限。注意Go中的公有私有是针对package而言的，在同一个package中，私有字段的访问级别相当于公有字段，也就是整个包中都是可见的，对于其他包而言，另一个包中的私有字段就是不可见的了
• 只能为同一个包中的类型定义方法
• Receiver可以是类型的值或者指针
• 不存在方法重载
• 可以使用值或者指针来调用方法，编译器会自动完成转换
• 从某种意义上来说，方法是函数的语法糖，因为receiver其实就是方法所接受的第一个参数（method value vs. method expression）
• 如果从外部结构和嵌入结构存在同名方法，则优先调用外部结构的方法
• 类型别名不会拥有底层类型所附带的方法
• 方法可以调用结构中非公开的字段

1
2
3
4
5
6
7
8
9
10
11
12

type A struct {
	Name string
}

func main() {
	v := A{"joe"}
	v.Print() // 输出结果joe
}

func (a A) Print() { /* 定义方法与定义函数的区别，在方法名前加上参数(recevierName receiverStructType)，这边receiver参数的传递依然遵循指针传递(加上*)和值传递的规律*/
	fmt.Println(a.Name)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 一般的类型也可以绑定方法
type TZ int

func main() {
	var v TZ = 1
	v.Print()
	fmt.Println(v)

	/* 运行结果：
	2
	2
	虽然TZ的底层还是int，但是TZ绑定了方法Print(),而int类型并没有绑定该方法(事实上内置类型int也不能够进行方法绑定)，
	这就是在Go中即使底层是相同的类型还是要进行显式转换的原因，因为底层相同的不同类型附带了各自不同的方法，
	所以它们本质上不能等价
	*/

}

func (a *TZ) Print() { // TZ类型绑定了方法Print
	*a = 2
	fmt.Println(*a)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 两种不同的形式来调用类型绑定的方法
type TZ int

func main() {
	var v TZ = 1
	v.Print()       // 法1 method value
	(*TZ).Print(&v) // 法2 method expression

	/* 运行结果：
	2
	2
	*/

}

func (a *TZ) Print() {
	*a = 2
	fmt.Println(*a)
}

Go中的interface:

• 接口是一个或者多个方法签名的集合
• 只要某个类型拥有该接口的所有方法签名，即算实现该接口，无需显式声明实现了哪个接口，这称为structural typing
• 接口只有方法声明，没有实现，没有数据字段
• 接口可以匿名嵌入其他接口，或者嵌入到结构中
• 将对象赋值给接口变量时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针
• 只有当接口存储的类型和对象都为nil时，借口才等于nil
• 接口调用不会做receiver的自动转换，结构调用的时候变量本身和指针都可以自动转换
• 接口同样支持匿名字段方法
• 接口也可以实现类似OOP中的多态
• 空接口可以作为任何类型数据的容器
• 通过类型的ok-pattern形式可以判断接口中的数据类型
• 使用type switch则可针对空接口进行比较全面的类型判断
• 接口可以转换，可以将拥有超集的接口转换成子集的接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

type USB interface {
	Name() string
	Connect()
}

type PhoneConnecter struct {
	name string
}

func (pc PhoneConnecter) Name() string {
	return pc.name
}

func (pc PhoneConnecter) Connect() {
	fmt.Println("Connected:", pc.name)
}

func main() {
	var a USB
	a = PhoneConnecter{"phoneConnecter"}
	a.Connect() // 输出结果：Connected: phoneConnecter
	Disconnect(a)
}

func Disconnect(usb USB) {
	fmt.Println("Disconnected:", usb.Name())
}
/*
    Connected: phoneConnecter
	Disconnected: phoneConnecter
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 接口的嵌入
type USB interface {
	Name() string
	Connecter
}

type Connecter interface {
	Connect()
}

type PhoneConnecter struct {
	name string
}

func (pc PhoneConnecter) Name() string {
	return pc.name
}

func (pc PhoneConnecter) Connect() {
	fmt.Println("Connected:", pc.name)
}

func main() {
	var a USB
	a = PhoneConnecter{"phoneConnecter"}
	a.Connect() // 输出结果：Connected: phoneConnecter
	Disconnect(a)
}

func Disconnect(usb USB) {
	fmt.Println("Disconnected:", usb.Name())
}
/*
    Connected: phoneConnecter
	Disconnected: phoneConnecter
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

type USB interface {
	Name() string
	Connecter
}

type Connecter interface {
	Connect()
}

type PhoneConnecter struct {
	name string
}

func (pc PhoneConnecter) Name() string {
	return pc.name
}

func (pc PhoneConnecter) Connect() {
	fmt.Println("Connected:", pc.name)
}

func main() {
	var a USB
	a = PhoneConnecter{"phoneConnecter"}
	a.Connect()
	Disconnect(a)
}

func Disconnect(usb USB) {
	if pc, ok := usb.(PhoneConnecter); ok { // 判断某变量是否是某类型，依然使用ok pattern的形式
		fmt.Println("Disconnected:", pc.name)
		return
	}
	fmt.Println("Unknown device.")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 使用空接口传入任何类型（除了接口类型之外，内置类型也可以）,然后使用type switch的形式判断具体是哪个类型
type USB interface {
	Name() string
	Connecter
}

type Connecter interface {
	Connect()
}

type PhoneConnecter struct {
	name string
}

func (pc PhoneConnecter) Name() string {
	return pc.name
}

func (pc PhoneConnecter) Connect() {
	fmt.Println("Connected:", pc.name)
}

func main() {
	var a USB
	a = PhoneConnecter{"phoneConnecter"}
	a.Connect()
	Disconnect(a)
}

func Disconnect(usb interface{}) {
	switch v := usb.(type) { // 括号内写type，让系统帮助我们进行判断
	case PhoneConnecter:
		fmt.Println("Disconnected:", v.name)
	default:
		fmt.Println("Unknown device.")
	}

}

Go中的反射：

• 反射可大大提高程序的灵活性，使得interface{}空接口有更大的发挥余地
• 反射使用TypeOf和ValueOf函数从接口中获取目标对象信息
• 反射会将匿名字段作为独立字段（匿名字段本质）
• 想要利用发射修改对象状态，前提是interface.data是settable，即pointer-interface
• 通过反射可以“动态”调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import (
	"fmt"
	"reflect"
)

// 使用TypeOf和ValueOf 反射出接口字段的信息和方法的信息
type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) Hello() {
	fmt.Println("hello world.")
}

func main() {
	u := User{1, "joe", 13}
	Info(u)
}

func Info(o interface{}) {
	t := reflect.TypeOf(o) // 得到空接口对象具体的类型并输出类型
	fmt.Println("Type: ", t.Name())

	v := reflect.ValueOf(o) // 得到空接口对象的所有字段
	fmt.Println("Fields: ")

	// 打印接口对象的所有字段
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		val := v.Field(i).Interface()
		fmt.Printf("%6s: %v = %v\n", f.Name, f.Type, val)

	}

	for i := 0; i < t.NumMethod(); i++ {
		m := t.Method(i)
		fmt.Printf("%s:%v", m.Name, m.Type)
	}

	/*运行结果：
	Type:  User
	Fields:
	    Id: int = 1
	  Name: string = joe
	   Age: int = 13
	Hello:func(main.User)   // 由此也可以看出receiver是方法的第一个参数
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) Hello() {
	fmt.Println("hello world.")
}

func main() {
	u := User{1, "joe", 13}
	Info(u)
}

func Info(o interface{}) {
	t := reflect.TypeOf(o)
	fmt.Println("Type: ", t.Name())

	if k := t.Kind(); k != reflect.Struct { // 使用Kind()来进行类型检查，看能不能使用反射
		fmt.Println("类型错误提示")
		return
	}

	v := reflect.ValueOf(o)
	fmt.Println("Fields: ")

	// 打印接口对象的所有字段
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		val := v.Field(i).Interface()
		fmt.Printf("%6s: %v = %v\n", f.Name, f.Type, val)

	}

	for i := 0; i < t.NumMethod(); i++ {
		m := t.Method(i)
		fmt.Printf("%s:%v", m.Name, m.Type)
	}

	/*运行结果：
	Type:  User
	Fields:
	    Id: int = 1
	  Name: string = joe
	   Age: int = 13
	Hello:func(main.User)   // 由此也可以看出receiver是方法的第一个参数
	*/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 使用反射获取嵌套的结构中的字段信息
type User struct {
	Id   int
	Name string
	Age  int
}

type Manager struct {
	User  /*该匿名字段相当于独立字段  User User 也就是说，相当于有一个与类型同名的User字段，所以使用时要以User：User{}的形式*/
	title string
}

func main() {
	m := Manager{User: User{1, "joe", 32}, title: "coo"}
	t := reflect.TypeOf(m)
	// 取嵌套的User中的Id字段，通过在FieldByIndex中传入一个int型的slice来取
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 0})) /*输出结果：reflect.StructField{Name:"Id", PkgPath:"", Type:(*reflect.rtype)(0x4a82c0), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:false}*/
}

1
2
3
4
5
6
7

// 使用反射修改值
func main() {
	x := 123
	v := reflect.ValueOf(&x) // 这边传入指针pointer interface才能进行修改
	v.Elem().SetInt(999)     // 使用Elem()函数获取指向x的指针
	fmt.Println(x)           // 输出999
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 使用反射修改目标对象
import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int
	Name string
	Age  int
}

func main() {
	u := User{1, "joe", 23}
	Set(&u)        // 既然要修改目标对象u，肯定要传入指针
	fmt.Println(u) // 输出结果：{1 john 23} 成功修改了Name字段的值
}

// set函数用于修改目标对象
func Set(o interface{}) {
	v := reflect.ValueOf(o)

	// 检查传入的参数是否是指针，是指针才可以修改  同时检查元素是否能被修改
	if v.Kind() == reflect.Ptr || !v.Elem().CanSet() {
		fmt.Println("对象类型非指针或对象不可被修改")
		return
	} else {
		v = v.Elem() //
	}

	f := v.FieldByName("Name") // 不仅可以通过index来获取结构的字段，还可以直接通过字段名
	if !f.IsValid() {          // IsValid()用于判断查找的Name字段是否存在
		fmt.Println("字段Name不存在")
		return
	}

	if f.Kind() == reflect.String { // 判断字段类型是否正确
		f.SetString("john") // 调用与字段类型对应的set函数进行修改
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 使用反射调用方法 效果就像是方法的动态调用
import (
	"fmt"
	"reflect"
)

type User struct {
	Id   int
	Name string
	Age  int
}

func (u User) Hello(name string) {
	fmt.Println("hello", name, ",my name is ", u.Name) // 输出结果:hello John ,my name is  joe
}

func main() {
	u := User{1, "joe", 23}

	// 使用反射调用Hello方法，并且传入一个Name字段
	v := reflect.ValueOf(u)       // 得到u的字段及绑定的方法
	mv := v.MethodByName("Hello") // 寻找到Hello方法

	args := []reflect.Value{reflect.ValueOf("John")} // args得到一个slice，作为调用方法的参数
	mv.Call(args)
}

MySQL是一个可移植的数据库，几乎能在当今所有的操作系统上运行，如Linux、Mac、Windows、Solaris、FreeBSD等。各种操作系统在底层实现（如线程）上各不相同，MySQL却能保证在各平台上物理体系结构的一致性。

数据库（database）和实例（instance）的概念
数据库：物理操作系统文件或者其他形式文件类型的集合。MySQL中，数据库文件可以是frm、myd、myi和ibd结尾的文件。使用NDB引擎时，数据库文件可能不是操作系统上的文件，而是存放在内存中的文件。
数据库实例：由数据库后台进程/线程以及一个共享内存区组成。共享内存可以被数据库后台进程/线程共享。数据库实例是真正用来操作数据库文件的。

在MySQL中，实例和数据库的关系是一一对应的。在集群状态下可能存在一个数据库被多个实例使用的情况。
从概念上说，数据库是文件（一般来说是二进制文件）的集合，是由一个个文件组成的，是按照某种数据模型组织起来并存放于二级存储器中的数据集合；数据库实例是应用程序，是位于用户与操作系统之间的一层数据管理软件，用户对数据库的任何操作（包括数据库的定义、查询、数据维护、数据库运行控制）都是由数据库实例来完成，其它应用程序只能通过与数据库实例进行交互才能访问数据库。即要对数据库中的一个个文件进行SELECT、INSERT、UPDATA和DELETE操作，不能直接通过操作文件来更改数据库中的内容，而是要通过数据库实例来完成对数据库的操作。

MySQL是一个单进程多线程结构的数据库。与SQL Server类似，与Oracle多进程的架构不同（Oracle的Windows版本也是单进程多线程架构）。MySQL数据库实例在操作系统上的表现就是一个进程。

MySQL体系结构

常见问题：
为什么MySQL不支持全文索引？
MySQL速度快是因为它不支持事务吗？
当表数据量大于1000W时，MySQL的性能会急剧下降吗？

解决这些问题需要理解MySQL数据库的体系结构。
MySQL由以下几个部分组成：

• 连接池组件(connection pool)
• 管理服务和工具组件(Management services and utilities)
• SQL接口组件(SQL interface)
• 查询分析组件(parser，解析)
• 优化器组件(optimizer)
• 缓冲（cache）组件
• 插件式存储引擎(pluggable storage engine)
• 物理文件 (files)

存储引擎是基于表的，不是数据库。MySQL区别于其他数据库的最重要的特点是其插件式的表存储器，插件式表存储器架构提供了一系列标准的管理和服务支持，这些标准和存储引擎本身无关，其中一些可能是每个数据库系统必须的，例如SQL分析器与优化器，存储引擎是底层物理结构的实现，其开发实现各不相同。

MySQL表存储引擎

插件式体系结构是MySQL数据库独有的，存储引擎是MySQL区别于其他数据库的最重要的特性，是MySQL数据库的核心。使用存储引擎的好处是在我们使用MySQL的过程中，能根据具体应用的不同，采用不同特点的存储引擎来建立不同的存储引擎表。
MySQL是开源的，我们可以根据MySQL预定义的存储引擎接口编写自己的存储引擎，如果我们对某种存储引擎不满意，也可以修改其源码来实现自己想要的特性。MySQL的存储引擎可以分为官方存储引擎和第三方存储引擎，InnoDB存储引擎就属于第三方存储引擎（Oracle收购）。

1 InnoDB存储引擎

InnoDB支持事务，主要面向在线事务处理(OLTP, online transaction processing)方面的应用。其特点是行锁设计、支持外键，支持类似于Oracle的非锁定读（默认情况下读取操作不会产生锁）。是MySQL在Windows版本下的默认存储引擎，也被默认地包含在所有MySQL二进制的发布版本中。

InnoDB将数据存放在一个逻辑表空间中，这个表空间就像一个黑盒一样由InnoDB自身进行管理。从MySQL4.1版本开始，每个InnoDB存储引擎的表可以被单独存放到一个独立的ibd文件中。与Oracle类似，InnoDB存储引擎同样可以使用裸设备（row disk）来建立其表空间。

InnoDB通过多版本并发控制（MVCC, multi-version concurrency control）来获得高并发性，而且实现了SQL标准的4中隔离级别，默认为REPEATABLE级别。使用一种next-key locking的策略来避免幻读现象（phantom）的产生。
此外，InnoDB还提供了插入缓冲（insert buffer）、二次写（double write）、自适应哈希索引（adaptive hash index）、预读（read ahead）等高性能高可用的功能。
对于表中数据的存储，InnoDB采用了聚集（clustered）的方式。该方式类似Oracle的索引聚集表（index organized table, IOT），每张表的存储都按照主键的顺序存放，如果没有显式地在表定义时指定主键，InnoDB会为每一行生成一个6字节的ROWID，以此作为主键。

2 MyISAM存储引擎

MyISAM存储引擎是MySQL官方提供的存储引擎。特点是不支持事务、表锁和全文索引，对于一些OLAP（online analytical processing，在线分析处理）操作速度快。除Windows版本外，MyISAM是所有MySQL的默认存储引擎。
MyISAM存储引擎表由MYD和MYI组成，MYD用来存放数据文件，MYI用来存放索引文件。可以通过使用myisampack工具来进一步压缩数据文件（压缩后可以用myisampack解压），myisampack使用霍夫曼（Huffman）编码静态算法来压缩数据，所以用它压缩后的表示只读的。
在MySQL5.0版本之前，MyISAM默认支持的表大小为4G，如果需要支持大于4G的MyISAM表时，需要指定MAX_ROWS和AVG_ROW_LENGTH属性。从MySQL5.0版本开始，MyISAM默认支持256T的单表数据，足以满足一般需求。

对于MyISAM存储引擎表，MySQL只缓存其索引文件，数据文件的缓存交由操作系统本身完成，而其他大部分数据库使用LRU算法缓存数据，与MyISAM不同。在MySQL 5.1.23版本之前，无论是在32位还是64位操作系统环境下，缓存索引的缓冲区最大只能设置为4G，之后的版本中，64位操作系统支持大于4G的索引缓冲区。

3 NDB存储引擎

NDB存储引擎是一个集群存储引擎，类似于Oracle的RAC集群，与RAC share everything结构不同的是，NDB的结构是share nothing的集群结构，能提供更高级别的可用性。NDB的特点是数据全部放在内存中（从5.1版本开始，可以将非索引数据放在磁盘上），因此主键查找（primary key lookup）速度极快，并且通过添加NDB数据存储节点（data node）可以线性地提高数据库性能，是高可用高性能的集群系统。
NDB存储引擎的连接操作（JOIN）是在MySQL数据库层而不是存储引擎层完成的。这意味着复杂的连接操作需要巨大的网络开销，所有查询速度很慢。

4 Memory存储引擎

Memory存储引擎（之前称为HEAP存储引擎）将表中的数据存放在内存中，如果数据库重启或发生崩溃，表中的数据都将消失。Memory非常适用于存储临时数据的临时表和数据仓库中的纬度表。Memory默认使用哈希索引而不是一般的B+树索引。
Memory存储引擎优点是速度非常快，缺点是只支持表锁，并发性能差；而且不支持TEXT(用来保存字符数据)和BLOB(用来保存二进制数据)列类型；其存储变长字段(varchar)时是按照定长字段(char)的方式进行的，会浪费内存。（eBay的Igor Chernyshev给出了Patch方案）
MySQL数据库使用Memory存储引擎作为临时表来存放查询的中间结果集(intermedia result)，如果中间结果集大于Memory存储引擎表的容量设置，或者中间结果集含有TEXT或者BLOB列类型字段，则MySQL数据库会把其转换到MyISAM存储引擎表而存放到磁盘。因为MyISAM不缓存数据文件，所以此时产生的临时表的查询性能会下降。

5 Archive存储引擎

Archive存储引擎只支持INSERT和SELECT操作，从MySQL5.1版本开始支持索引。使用zlib算法将数据行(row)进行压缩后存储，压缩比率一般高达1:10。Archive存储引擎非常适合存储归档数据，如日志信息。Archive使用行锁来实现高并发的插入操作，但它本身并不是事务安全的存储引擎，其设计目标主要是提供高速的插入和压缩功能。

6 Federated存储引擎

Federated存储引擎表并不存放数据，它只是指向一台远程MySQL数据库服务器上的表，类似于SQL Server的链接服务器和Oracle的透明网关，不同的是当前Federated存储引擎只支持MySQL数据库表，不支持易购数据库表。

7 Maria存储引擎

Maria的设计目标是用来取代原有的MyISAM存储引擎，从而成为MySQL的默认存储引擎，它可以看成是MyISAM的后续版本。特点是缓存数据和索引文件，行锁设计，提供MVCC功能，支持事务和非事务安全的选项支持，更好的BLOB字符类型的处理性能。

8 其他存储引擎

上面7种存储之外还有Merge、CSV、Sphinx和Infobright等，它们有各自适用的场景。
几个问题的回答：
为什么MySQL不支持全文索引？MySQL支持全文索引，MyISAM、Sphinx等存储引擎都支持全文索引。
MySQL速度快是因为它不支持事务吗？不是，MySQL中MyISAM存储引擎不支持事务，但是InnoDB支持。速度快要针对不同的应用场景，对于ETL(extract-transform-load, 数据抽取-转换-装载)操作，MyISAM有优势。
当表的数据量大于1000W时，MySQL的性能会急剧下降吗？不会，MySQL是数据库，不是文件，随着数据行数的增加，MySQL的性能会有所下降，但是这样的性能下降不是线性的。选择合适的存储引擎和配置，再大的数据量MySQL也能承受。案例：Mytrix在InnoDB上存储了超过1TB的数据；一些网站使用InnoDB存储引擎处理平均每秒800次的插入/更新操作。

各种存储引擎之间的比较

存储引擎是MySQL体系结构的核心。
不同MySQL存储引擎相关特性比较：

MySQL的设计者认为不是所有的应用都需要事务，所以存在不支持事务的存储引擎。可以通过SHOW ENGINES语句查看当前使用的MySQL数据库支持的存储引擎，也可以通过information_schema架构下的ENGINES表来查看。

互联网的网络架构由C/S架构转变为B/S架构

B/S架构的好处：

1. 客户端使用统一的浏览器（Browser）。不需要特殊的配置和网络连接就可以使用所有服务提供商提供的服务。同时也方便了用户的使用。
2. 服务端（Server）基于统一的HTTP。C/S架构使用自定义应用层协议，B/S架构使用统一的HTTP协议。使用统一的HTTP协议减少了服务提供商的开发成本。基于HTTP的服务器（如Apache、IIS、Nginx、Tomcat、Jboss）和开发服务的通用框架有很多，使得服务开发者开发成本降低。

1 B/S网络架构

大多数C/S互联网应用程序使用长连接交互模式，而B/S采用应用层的HTTP来交互数据，HTTP采用无状态的短连接方式，即通常情况下，一次请求就完成了一次数据交互，也就是完成了一个业务逻辑，完成之后这次通信连接就断开了。

采用短连接的目的是能够同时服务更多用户，互联网应用每天会处理上亿次用户请求，不可能每个用户访问一次后一直保持这个连接。

用户在浏览器中输入 www.taobao.com 这个URL之后，发生了哪些操作？
首先浏览器请求DNS服务器将域名解析为对应的IP地址；
然后浏览器根据IP地址找到互联网上对应的服务器，向服务器发送一个get请求；
服务器端的服务器可能有很多台，负载均衡(Load Balance)服务器收到get请求后来平均分配所有的用户请求，指定到底哪台服务器来处理请求；
指定的服务器收到请求后根据请求的数据所在的位置（可能存储在分布式缓存中、静态文件中或是数据库中）返回数据资源给用户；
浏览器收到返回的数据后，浏览器解析数据，如果发现数据中有一些静态资源（如CSS、JS或图片），则浏览器又会发起另外的HTTP请求，这些请求很可能会在CDN（content delivery network，内容分发网络，通过在网络各处放置节点服务器，实时的根据网络流量和各节点的连接、负载状况以及到用户的距离和响应时间等综合信息将用户的请求重新导向离用户最近的服务节点上，使得用户可以就近取得所需的内容，解决网络拥挤状况，提高网站响应速度。）上，CDN服务器再处理这个用户请求。

CDN架构图：

不管上面的网络结构如何变化，一些始终遵循的固定原则：

1. 互联网上所有资源都要用一个URL表示。
2. 必须基于HTTP与服务端交互。不管访问的数据是在国内的还是在国外，是文本数据还是流媒体（传输过程中使用了流技术的多媒体数据，流技术即把连续的影像和声音信息经过压缩处理后放到网站服务器让用户一边下载一边观看收听，不需要将整个压缩文件都下载下来后才可以使用的网络传输技术），都必须按照统一的HTTP请求的方式，这样服务器端才能正确得知请求的是什么。
3. 数据的展示必须在浏览器中进行。当用户获取到请求的数据资源后，必须在浏览器上最终解析展示。

2 如何发起一个HTTP请求

发起一个HTTP请求的过程就是建立一个Socket通信的过程。

3 HTTP解析

HTTP是B/S架构的核心。要理解HTTP，最重要的是要熟悉HTTP中的HTTP Header。

什么是HTTP协议？
HTTP(hypertext transfer protocol，超文本传输协议)协议定义了浏览器向WWW服务器请求数据以及服务器向浏览器返回数据的方法。HTTP协议使用了面向连接的TCP作为运输层协议，保证数据的可靠传输，HTTP不考虑数据在传输过程中被丢弃后又怎样重传。HTTP协议本身是无连接的。即虽然HTTP使用了TCP连接，但是通信的双方在交换HTTP报文之前不需要先建立HTTP连接。HTTP协议是无状态的。即同一个用户第二次访问同一个服务器上的资源时，服务器的响应与第一次被访问时的相同（假定请求的数据在服务器上没有更新）。因为服务器不需要记录曾经请求数据的用户信息，也不需记录为该用户返回过几次数据，所以HTTP的无状态特点简化了服务器的设计，使得服务器更容易支持大量并发的HTTP请求。

当浏览器向服务器发送get请求时，HTTP协议规定首先要建立浏览器与服务器之间的TCP连接。这样的连接过程需要三次握手，当三次握手的前两部分完成后（即经过一个RTT（round-trip time,往返时间，表示从发送方发送数据开始，到发送方收到来自接收方的确认总共经历的时间，其间接收方收到数据后立刻发送确认）时间后），浏览器就把HTTP请求报文作为三次握手的第三个报文的数据发送给服务器。服务器收到HTTP请求之后，就把所请求的文档作为响应报文返回给客户。
请求一个WWW资源所需的时间是该资源的传输时间（与资源的大小成正比）加上两倍的RTT（一个RTT用于建立TCP连接，另一个RTT用于请求和接受资源）。这里TCP建立连接的三次握手的第三个报文段中捎带了浏览器对WWW资源的请求。

请求服务器资源所需时间:

HTTP报文结构
HTTP有两类报文：请求报文与响应报文
HTTP是面向文本的（text-oriented），报文中的每一个字段都是一些ASCII码串，因此各个字段的长度都是不确定的。
HTTP请求报文和响应报文都是由三部分组成（两种报文的区别是报文的开始行不同）：
（1）开始行（start-line），用于区分是请求报文还是响应报文。请求报文中的开始行叫做请求行（request line），响应报文中的开始行叫做状态行（status line）。开始行的三个字段之间都以空格分隔开，最后的CR与LF分别代表回车与换行。
（2）首部行（message-header），用来说明浏览器、服务器和报文主体的一些信息。首部可以有好几行，也可以不使用。每一个首部行中有首部字段名和对应的值，每一行以回车和换行结束。整个首部行结束时，还有一空行将首部行与实体主体分开。
（3）报文主体（message-body），请求报文中一般不使用这个字段，在响应报文中也可能不使用

HTTP Message:

1
2
3
4
5

generic-message = start-line
                  *(message-header CRLF)
                  CRLF
                  [ message-body ]
start-line      = Request-Line | Status-Line

HTTP请求报文（request message）结构与响应报文（response message）结构：

HTTP请求报文的请求行由三项内容组成：方法（操作）、请求资源的URL、以及HTTP的版本。

HTTP请求报文的一些方法：

常见HTTP请求头:

HTTP响应报文的状态行包括三项内容，即HTTP的版本，状态码，以及解释状态码的简单短语。
状态码（status-code）由三位数字组成，分为5大类共33种（见RFC2616）:
1xx：表示通知信息，如请求已经收到或正在处理
2xx：表示成功（Successful）
3xx：表示重定向（Redirection），如要完成请求还必须采取进一步的行动
4xx：表示客户端错误（client error），如400客户端请求有语法错误，不能被服务器识别
5xx：表示服务端错误（server error），如500服务器内部错误，服务器发生了意料之外的错误情况导致服务器不能满足客户端发来的请求

常见的HTTP状态码：

常见的HTTP响应头：

3.2 浏览器缓存机制

当我们浏览一个页面发现有异常情况时，通常考虑的就是是不是浏览器做了缓存，一般的做法是使用ctrl+F5组合键来重新请求该页面，重新请求的最新的页面。ctrl+F5组合键可以保证浏览器会直接向目标URL发送请求而不使用浏览器缓存的数据；同时当我们使用ctrl+F5来刷新页面时，HTTP的请求头中会增加一些请求头，这些请求头用于告诉服务端我们要获取最新的数据而不是缓存，这样可以避免请求发送到服务端时访问到的是服务端缓存的数据（例如应用服务器的前端部署了一个缓存服务器，如Varnish代理，Varnish可能直接使用缓存数据）

使用ctrl+F5组合键后HTTP请求头会发生什么改变
使用ctrl+F5组合键后HTTP请求头中会增加两个请求项：Pragma:no-cache和Cache-Control:no-cache。

未使用ctrl F5组合键的HTTP请求头：

使用了ctrl F5组合键的HTTP请求头：

3.2.1 Cache-control和Pragma两项配置项的作用

该两项HTTP Head字段用于指定所有缓存机制在整个请求/响应链中必须服从的指令。

HTTP head字段的可选值：

Cache-Control请求字段被各个浏览器支持得较好，且它的优先级较高，当Cache-Control和其他请求字段（如Expires）同时出现时，Cache-Control会覆盖其他字段。
Pragma字段的作用和Cache-Control类似，也是在HTTP头中包含的一个特殊的指令，对服务器的行为做一个规约，最常用的是Pragma:no-cache，与Cache-Control:no-cache的作用一样。

3.2.2 Expires

Expires通常使用的格式是Expires后面跟一个日期和时间，如Expires:Sat,25 Feb 2012 12:22:17 GMT，表示的意义是超过这个时间，缓存的内容就会失效。浏览器在发出请求之前会检查该页面的这个字段，如果缓存的内容已经失效，即该页面已经过期，就会重新向服务器发起请求。

3.2.3 Last-Modified/Etag

Last-Modified 字段一般用于表示一个服务器上的资源的最后修改时间。服务器在响应头中返回一个Last-Modified字段，告诉该浏览器的最后修改时间，如Last-Modified:Sat,25 Feb 2012 12:55:04 GMT，浏览器再次发送请求时在请求头中添加字段If-Modified-Since:SatSat,25 Feb 2012 12:55:04，询问当前缓存的页面是否是最新的，如果是最新的返回304状态码，告诉浏览器缓存的页面是最新的，服务器也不会返回最新的数据。
Etag字段的功能与Last-Modified字段类似，该字段的作用是让服务器给每一个页面分配一个唯一的编号，通过这个编号来确定缓存的页面是否是最新的。该方式比Last-Modified更加灵活，缺点是当后端的Web服务器有多台时，需要每个Web服务器都记住网站的所有资源，否则浏览器返回的这个编号就失去了存在的意义。

4 DNS域名解析

互联网都是通过域名来发布和请求资源，但是不同计算机之间是通过IP地址来建立网络连接。DNS解析就是将URL中的域名需要解析成IP地址。

4.1 DNS域名解析过程:
当一个用户在浏览器中输入网站域名并按下回车键后，DNS解析有近10个步骤：
第一步：浏览器检查缓存中是否有该域名解析过的IP地址，如果有，则DNS解析过程结束。浏览器中缓存的域名对应的IP地址的大小和时间都是有限制的，通常时间在几分钟到几小时不等，可以通过TTL属性（time to live，记录域名解析结果在DNS服务器上的保留时间）对浏览器中缓存的域名对应的IP地址的存在时间进行设置。缓存时间不宜太长或者太短，如果太长，一旦域名被解析到的IP地址有变化，浏览器中缓存的IP地址即失效，会导致该域名不能正常解析，用户无法正常访问网站；如果缓存的时间太短，会导致用户每次访问网站都要重新解析一次域名，缓存的意义不再。

第二步：如果浏览器中没有该域名对应的解析过的IP地址缓存，则浏览器会检查操作系统的hosts文件。操作系统中的hosts文件缓存了一些域名对应的DNS解析结果。如果hosts文件中指定了一个域名的IP地址，那么浏览器会首先使用这个IP地址。这样的做法带来的好处：我们在网站测试过程中可以把域名解析到一台测试服务器上，这样我们不需要修改任何代码就能测试到单独服务器上代码的业务逻辑是否正确；这样的做法带来的坏处：本地DNS解析的过程可能被黑客利用，黑客可以通过修改本地的域名解析来把特定的域名解析到他指定的IP地址，导致域名劫持。
Windows系统中该本地配置文件的地址在C:\Windows\System32\drivers\etc\hosts，Linux系统中该文件的地址在/etc/hosts，当操作系统解析到这个配置文件中的域名时，操作系统会在缓存中缓存这个解析结果，缓存的时间受该域名的失效时间和缓存的空间大小控制。

第一步和第二步的域名解析过程都是在本机完成的，在本机中无法完成的域名解析，就会请求域名服务器来解析该域名。

第三步：当上面两步无法完成域名解析时，操作系统会把该域名发送给本地区域名服务器，即LDNS，网络配置中的“DNS服务器地址”这一项就设置了LDNS的地址。LDNS在本地互联网中，如果是学校中接入互联网，则所属的LDNS服务器肯定在学校里，如果是在小区中接入电信或移动（SPA,service provider ）互联网，则所属的LDNS服务器通常会在城市中不远处的某处。LDNS服务器缓存了域名解析的结果，缓存的时间受域名的失效时间控制，缓存空间不足是域名解析不成功的主要因素。LDNS的性能通常会很好，它承担了域名解析的主要工作，80%的域名解析到这里就完成了。Windows下可以通过ipconfig/all查看LDNS服务器的地址，Linux下可以通过cat /etc/resolv.conf查看。
Windows中查看DNS server地址：

第四步：如果LDNS仍然没有命中请求的域名，则直接到Root Server根域名服务器请求解析。

第五步：根域名服务器返回给本地域名服务器一个所查询域的主域名服务器（gTLD Server, generic top-level domain，通用顶级域）地址。gTLD是国际顶级域名服务器，如.com、.cn、.org等。

第六步：本地区域名服务器LDNS再向上一步返回的gTLD服务器发送请求。

第七步：接受请求的gTLD服务器查找并返回此域名对应的Name Server域名服务器的地址，这个Name Server通常就是注册的域名服务器，例如在某个域名服务提供商申请的域名，则该域名解析任务就由这个域名提供商的服务器来完成。

第八步： Name Server域名服务器会查询存储的域名和IP的映射关系表，在正常的情况下都根据域名得到的IP地址，连通一个TTL值返回给DNS Server域名服务器。

第九步：返回该域名对应的IP和TTL值，LDNS服务器会缓存这个域名和IP地址的对应关系，缓存的时间由TTL控制。

第十步：把解析的结果返回给用户，用户根据TTL值将结果缓存在本地的系统缓存中，域名解析过程结束。

在实际的DNS解析过程中，可能会超过上述10个步骤，如Name Server可能有多级，或者有一个GTM（global traffic manager，全球流量管理器，一种负载均衡组件）来负载均衡控制，这都可能影响域名解析的过程。

DNS域名解析过程：

4.2 跟踪域名解析过程
在Linux和Windows下都可以使用nslookup命令来查询域名解析结果；在Linux下还可以使用dig 域名来查询DNS的解析过程。
Windows命令行下使用nslookup来查看域名解析结果：

4.3清除缓存的域名
DNS域名解析后会在Local DNS Server和本机上缓存解析结果，这两个缓存都是由TTL值和缓存空间的大小控制的，最大缓存时间即TTL值。Local DNS Server的缓存时间就是TTL值，很难人工介入来进行更改。本机缓存可以进行人工清除。

本机缓存的清除方法：
在Windows的命令行中使用ipconfig/flushdns命令来刷新缓存。
在Linux下可以使用/etc/init.d/nscd restart来清除缓存。

在Java应用中，JVM也会缓存DNS的解析结果，这个缓存是在InetAddress类中完成的，这个缓存时间较为特殊，有两种缓存策略：一种是正确解析结果缓存，另一种是失败的解析结果缓存。这两个缓存时间由两个配置项控制，配置项是在%JAVA_HOME%\lib\security\java.security文件中配置的。两个配置项分别是networkaddress.cache.ttl和networkaddress.cache.negative.ttl，它们的默认值分别是-1（永不失效）和10（缓存10秒）。
要修改这两个值有如下几种方式，分别是：直接修改java.security文件中的默认值；在Java的启动参数（运行程序是加上JVM参数）中增加-Dsun.net.inetaddr.ttl=xxx来修改默认值；通过InetAddress类动态修改。
需要特别注意的是，如果我们使用InetAddress类解析域名，必须是单例模式，不然会有严重的性能问题，如果每次都创建InetAddress实例，则每次都要进行一次完整的域名解析，非常耗时。

4.4 几种域名解析方式
域名解析记录主要分为A记录、MX记录、CNAME记录、NS记录和TXT记录。

• A记录：A代表Address，用来指定域名对应的IP地址。如将item.taobao.com指定到115.238.23.xxx，将switch.taobao.com指定到121.14.24.xxx。A记录可以将多个域名解析到一个IP地址，但不能将一个域名解析到多个IP地址。
• MX记录：MX代表Mail Exchange，就是可以将某个域名下的邮件服务器指向自己的Mail Server，如taobao.com域名的A记录IP地址是115.238.25.xxx，如果将MX记录设置为115.238.25.xxx，即xxx@taobao.com的邮件路由，DNS会将邮件发送到115.238.25.xxx所在的服务器，同时正常通过Web请求的话仍然能解析到A记录的IP地址。
• CNAME记录：全程是Canonical name(别名解析)。所谓的别名解析就是可以为一个域名设置一个或多个别名。即将域名指向另一个域名，再通过另一个域名提供IP地址。
• NS记录：域名服务器记录。意义是为某个域名指定DNS解析服务器，也就是这个域名由指定的IP地址的DNS服务器去解析。如果需要把子域名交给其他DNS服务商解析，就需要添加NS记录。
• TXT记录：为某个主机名或者域名设置说明，该项可以填写任何东西，长度限制255。