一、Go开发环境

1. GOROOT

就是Go的安装路径。

2. GOPATH

GOPATH 是作为编译后二进制的存放目的地和 import 包时的搜索路径 （其实也是你的工作目录，你可以在 src 下创建你自己的 go 源文件，然后开始工作）。

GOPATH 之下主要包含三个目录：

• bin：目录主要存放可执行文件；
• pkg：目录存放编译好的库文件；
• src：目录下主要存放 Go 的源文件。

3. 程序的运行

$ go run xxx.go    // go run 命令， 将 .go源文件进行编译、链接，然后运行生产可执行文件
$ go build xxx.go  // go build 命令，编译生成一个可执行程序

二、Go语言基础

1. 常量

const limit = 512
const top uint16 = 1421
const Pi float64 = 3.1415926
const x, y, z int = 1, 3, 5   //多重赋值

iota 是一个可以被编译器修改的常量，在 const 关键字出现时被重置为 0，在下一个 const 出现之前，每出现一次 iota，其所代表的数字自动加 1。

const (
  a = iota  // a == 0
  b = iota  // b == 1
  c = iota  // c == 2
)
const d = iota  // d == 0, 因为const的出现，iota被重置为0。

2. 变量

var a int
var b string
var c float64
var d [5] int    // 数组
var e [] int     // 数组切片
var f int = 5
var g = 55       // 自动类型推导（省略了int的显式声明）
h := 666         // 省略 var，省略 int

交换两个变量：

x := 2
y := 3
x, y = y, x      // Go支持多重赋值

3. 数据类型

3.1 整型

类型	说明
byte	等同于 uint8
int	依赖于不同平台下的实现，可以是 int32 或者 int64
int8	[-128, 127]
int16	[-32768, 32767]
int32	[-2147483648, 2147483647]
int64	[-9223372036854775808, 9223372036854775807]
rune	等同于 int32
uint	依赖于不同平台下的实现，可以是 uint32 或者 uint64
uint8	[0, 255]
uint16	[0, 65535]
uint32	[0, 4294967295]
uint64	[0, 18446744073709551615]
uintptr	一个可以恰好容纳指针值的无符号整型（对 32 位平台是 uint32, 对 64 位平台是 uint64）

查看某数据类型的字节长度：

var x int64 = 12
fmt.Println("length of int64 :", unsafe.Sizeof(x))    // length of int64 : 8

3.2 浮点型

类型	说明
float32	±3.402 823 466 385 288 598 117 041 834 845 169 254 40x1038 计算精度大概是小数点后 7 个十进制数
float64	±1.797 693 134 862 315 708 145 274 237 317 043 567 981x1038 计算精度大概是小数点后 15 个十进制数
complex32	复数，实部和虚部都是 float32
complex64	复数，实部和虚部都是 float64

3.3 布尔型

go语言提供了布尔值 true 和 false. 不接受其他类型的赋值，不支持类型转换。

var a bool
a = true 
b := (2 == 3)

3.4 字符串

转义字符	含义
\	表示反斜线
'	单引号
"	双引号
\n	换行符
\uhhhh	4 个 16 进制数字给定的 Unicode 字符

在Go语言中单个字符可以使用单引号' ' 来创建。

一个单一的字符可以用一个单一的rune来表示。 rune类型，等同于 int32。

字符串支持的操作如下：

语法	描述
s += t	将字符串 t 追加到 s 末尾
s + t	将字符串 s 和 t 级联
s[n]	从字符串 s 中索引位置为 n 处的原始字节
s[n:m]	从位置 n 到位置 m-1 处取得的字符（字节）串
s[n:]	从位置 n 到位置 len(s)-1 处取得的字符（字节）串
s[:m]	从位置 0 到位置 m-1 处取得的字符（字节）串
len(s)	字符串 s 中的字节数
len([]rune(s))	字符串 s 中字符的个数，可以使用更快的方法 utf8.RuneCountInString()
[ ]rune(s)	将字符串 s 转换为一个 unicode 值组成的串
string(chars)	chars 类型是 []rune 或者 []int32, 将之转换为字符串
[ ]byte(s)	无副本的将字符串 s 转换为一个原始的字节的切片数组，不保证转换的字节是合法的 UTF-8 编码字节

3.5 格式化字符串

格式化指令	含义
%%	% 字面量
%b	一个二进制整数，将一个整数格式化为二进制的表达方式
%c	一个 Unicode 的字符
%d	十进制数值
%o	八进制数值
%x	小写的十六进制数值
%X	大写的十六进制数值
%U	一个 Unicode 表示法表示的整形码值，默认是 4 个数字字符
%s	输出以原生的 UTF-8 字节表示的字符，如果 console 不支持 UTF-8 编码，则会输出乱码
%t	以 true 或者 false 的方式输出布尔值
%v	使用默认格式输出值，或者使用类型的 String() 方法输出的自定义值，如果该方法存在的话
%T	输出值的类型

3.6 字符类型

Go语言中支持两个字符类型：

Byte （实际上是 Unit8的别名）， 代表UTF-8字符串的单个字节的值。

rune ， 代表单个 Unicode字符。

3.7 数组

数组是一个定长的序列，其中每个元素的类型都相同。 固定长度，不可修改。

var a [5] int
var b = [5]int{1,2,3,4,5}
var c = [...]int{1,2,3,4,5}    // 如果使用了省略号，Go语言会为我们自动计算数组的长度。

3.8 切片

Go语言的切片比数组更加灵活、强大、方便！ 切片不定长，可以随时调整长度。

数组是按值传递的（即传递的副本），而切片是引用类型，传递切片的成本非常小。

var a make([]int, 10, 20)      // 切片的长度和容量分别为 10 和 20
var b = []int{1,2,3,4,5}

3.9 包

Go语言中的代码组织方式是包。 包是各种类型和函数的集合。

在包中，如果标识符的首字母是大写的，那这些标识符是可以被导出的，可以在包以外直接使用。

4. 流程控制

if aBoolValue {
  block1
}else if anotherBoolValue {
  block2
}else {
  block3
}

go语言只支持for循环语句，不支持 while / do-while语句。

sum := 0 
for i := 0; i < 10; i++ { 
    sum += i 
}  

for boolVlaue {
                            // while 循环。 Go语言中没有while关键字
}
for index, char := range aString {
                  // 迭代字符串
}
for item := range aChannel {
                  // 迭代通道
}

switch aExpression {
  case expression1:
      block1
  ... 
  case expressionN:
        blockN
  default:
        BlockD
}

5. 函数

package Divide
func divide(a int, b int) (num int, err error) {
  if b == 0 {
    err := errors.New("被除数不能为0")
    return
  }
  return a / b, nil           // 支持返回多个值。不必创建临时的结构体来包装。
}

// 下面是函数的调用
package main
import (
  "Divide"          // 导入 Add 包
  "fmt"
)
func main() {
  c, err := Divide.divide(1,2)
  if err==nil {
    fmt.Println(c)
  }
}

5.1 匿名函数

匿名函数由一个不带函数名的函数声明和函数体组成。

func (a,b,c int) bool {
  return a * b < c
}

你可以将匿名函数直接赋值给一个变量，也可以直接调用运行。

x := func (a,b,c int) bool {
  return a * b < c
}

func (a,b,c int) bool {
  return a * b < c
} (1,2,3)                 // 小括号内直接给参数列表 表示函数调用

接口是一个自定义类型。它声明了一个或者多个方法。任何实现了这些方法的对象（类型）都满足这个接口。

var i interface{} = 99              // 创建一个interface{}类型，其值为99
    var s interface{} = []string{"left", "right"}
    j := i.(int)                    // 我们假设i是兼容int类型，并使用类型断言将其转换为int类型
    fmt.Printf("type and value of j is: %T and %d\n", j, j)

    if s, ok := s.([]string); ok {  // 创建了影子变量，if的作用域中覆盖了外部的变量s
        fmt.Printf("%T -> %q\n", s, s)
    }

5.2 defer

defer 语句是在 return 之后执行的。

func CopyFile(dst, src string) (w int64, err error) {
    srcFile, err := os.Open(src)
    if err != nil {
        return
    }
    defer srcFile.Close()
    dstFile, err := os.Create(dst)
    if err != nil {
        return
    }
    defer dstFile.Close()
    return io.Copy(dstFile, srcFile)
}

5.3 panic & recover

panic() 函数用于抛出异常，recover() 函数用于捕获异常。

6. 结构体

type ColorPoint struct {
  color.Color            // 匿名字段(嵌入)
  x, y int                           // 具名字段(聚合)
}

7. 方法

方法是作用在自定义类型上的一类特殊函数。

定义方法和定义函数几乎相同，只是需要在 func 关键字和方法名之间必须写上接接受者。

type Count int
func (count *Count) Increment() {        // 接受者是一个 `Count` 类型的指针
  *count++
}

8. 组合

Go 语言中没有继承。 但是提供了一个组合特性。

相对于继承的编译期确定实现，组合的运行态指定实现，更加灵活。

9. 接口

Go中接口是一组方法签名。当一个类型为接口中的所有方法提供定义时，它被称为实现该接口。

infterface{} 类型是声明了空方法集的接口类型。任何一个值都满足 interface{} 类型，也就是说如果一个函数或者方法接收 interface{} 类型的参数，那么任意类型的参数都可以传递给该函数。

package main
import "fmt"
type Human struct { // 结构体
    name  string
    age   int
    phone string
}

//Human实现SayHi方法
func (h Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

//Human实现Sing方法
func (h Human) Sing(lyrics string) {
    fmt.Println("La la la la...", lyrics)
}

type Student struct {
    Human  //匿名字段
    school string
    loan   float32
}

type Employee struct {
    Human   //匿名字段
    company string
    money   float32
}

// Employee重载Human的SayHi方法
func (e Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone)
}

// Interface Men被Human,Student和Employee实现
// 因为这三个类型都实现了这两个方法
type Men interface {
    SayHi()
    Sing(lyrics string)
}

func main() {
    mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    Tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}

    //定义Men类型的变量i
    var i Men

    //i能存储Student
    i = mike
    fmt.Println("This is Mike, a Student:")
    i.SayHi()
    i.Sing("November rain")

    //i也能存储Employee
    i = Tom
    fmt.Println("This is Tom, an Employee:")
    i.SayHi()
    i.Sing("Born to be wild")

    //定义了slice Men
    fmt.Println("Let's use a slice of Men and see what happens")
    x := make([]Men, 3)
    //这三个都是不同类型的元素，但是他们实现了interface同一个接口
    x[0], x[1], x[2] = paul, sam, mike

    for _, value := range x {
        value.SayHi()
    }
}

三、并发编程

1. 并发与并行

并发指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，通过 CPU 时间片轮转使多个进程快速交替的执行。而并行的关键是你有同时处理多个任务的能力。

并发和并行都可以是很多个线程，就看这些线程能不能同时被（多个）CPU 执行，如果可以就说明是并行，而并发是多个线程被（一个）CPU 轮流切换着执行。

并发与并行的区别：并发是两个队列，使用一台咖啡机；并行是两个队列，使用两台咖啡机。如果串行，一个队列使用一台咖啡机，那么哪怕前面那个人有事出去了半天，后面的人也只能等着他回来才能去接咖啡，这效率无疑是最低的。

2. 协程

协程也叫轻量级线程。与传统的进程和线程相比，协程最大的优点就在于其足够“轻”，操作系统可以轻松创建上百万个协程而不会导致系统资源枯竭，而线程和进程通常最多不过近万个。

多数语言在语法层面上是不支持协程的，一般都是通过库的方式进行支持，但库的支持方式和功能不够完善，经常会引发阻塞等一系列问题，而 Go 语言在语法层面上支持协程，也叫 goroutine。这让协程变得非常简单，让轻量级线程的切换管理不再依赖于系统的进程和线程，也不依赖 CPU 的数量。

3. goroutine

goroutine 是 Go 语言并行设计的核心。goroutine 是一种比线程更轻量的实现，十几个 goroutine 可能在底层就是几个线程。

要使用 goroutine 只需要简单的在需要执行的函数前添加 go 关键字即可。

func Add(a, b int) {
  c := a + b
  fmt.Println(c)
}
go Add(1, 2)                  // 使用 go 关键字让函数并发执行

当在一个函数前加上 go 关键字，该函数就会在一个新的 goroutine 中并发执行，当该函数执行完毕时，这个新的 goroutine 也就结束了。

4. channel

Go 语言提供的信道（channel）就是专门解决并发通信问题的.

channel 是goroutine 之间互相通讯的东西。类似我们 Unix 上的管道（可以在进程间传递消息），用来 goroutine 之间发消息和接收消息。其实，就是在做 goroutine 之间的内存共享。

var a chan int            // 声明一个传递元素类型为int的channel
var b chan float64
var c chan string

x := make(chan int)       // 声明并初始化一个int型的名为a的channel
y := make(chan float64)
z := make(chan string)

channel 最频繁的操作就是写入和读取，这两个操作也非常简单：

a := make(chan int)
a <- 1                    // 将数据写入channel
z := <-a                  // 从channel中读取数据

channel的关闭非常简单，使用 Go 语言内置的 close() 函数即可关闭 channel

ch := make(chan int)
close(ch)

5. select

select 用于处理异步 IO 问题，它的语法与 switch 非常类似。由 select 开始一个新的选择块，每个选择条件由 case 语句来描述，并且每个 case 语句里必须是一个 channel 操作。

func main() {
    c1 := make(chan string)    // 初始化两个 channel c1 和 c2
    c2 := make(chan string)
    go func() {            // 开启两个 goroutine 分别往 c1 和 c2 写入数据
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()
    for i := 0; i < 2; i++ {
        select {                  // 通过 select 监听两个 channel
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

6. 超时机制

t := make(chan bool)
go func {
    time.Sleep(1e9) //等待1秒
    t <- true
}
select {
    case <-ch:  //从ch中读取数据
    case <-t:  //如果1秒后没有从ch中读取到数据，那么从t中读取，并进行下一步操作
}

这样的方法就可以让程序在等待 1 秒后继续执行，而不会因为 ch 读取等待而导致程序停滞，从而巧妙地实现了超时处理机制，这种方法不仅简单，在实际项目开发中也是非常实用的。