剖析 golang 的25个关键字
基本在所有语言当中，关键字都是不允许用于自定义的，在Golang中有25个关键字，图示如下：
下面我们逐个解析这25个关键字。
var && const
使用var关键字是Go最基本的定义变量方式，有时也会使用到 := 来定义变量。
定义变量
var name string 复制代码
定义变量并初始化值
var name string = "keywords" 复制代码
同时初始化多个同类型变量
var name1, name2, name3 string = "name1", "name2", "name3" 复制代码
同时初始化多个不同类型变量
var ( name string = "keywords", count int = 2 ) 复制代码
也可省略变量类型
var name1, name2, name3 = "name1", "name2", "name3" 复制代码
使用 := 这个符号取代var和type,这种形式叫做简短声明。不过它有一个限制，那就是它只能用在函数内部；在函数外部使用则会无法编译通过，所以一般用var方式来定义全局变量。
name1, name2, name3 := "name1", "name2", "name3" 复制代码
const 用来声明一个常量，const 语句可以出现在任何 var 语句可以出现的地方，声明常量方式与 var 相同，这里就不在赘述了。但是需要注意的是，const 声明的是常量，一旦创建，不可赋值修改。
package && import
包是函数和数据的集合。用 package 关键字定义一个包，用 import 关键字引入一个包，文件名不需要和包名一致。包名的约定是使用小写字符。Go 包可以由多个文件组成，但是使用相同的 package 这一行。
当函数或者变量等首字母为大写时，会被导出，可在外部直接调用。
包名是导入的默认名称。可以通过在导入语句指定其他名称来覆盖默认名称
import bar "bytes" 复制代码
map
map 是 Go 内置关联数据类型（在一些其他的语言中称为哈希 或者字典 ）。
创建一个空 map
m := make(map[string]int) 复制代码
设置键值对对map赋值
m["k"] = 7 复制代码
使用 name[key] 来获取一个键的值
v := m["k"] fmt.Println("v: ", v) 复制代码当对一个 map 调用内建的 len 时，返回的是键值对数目
fmt.Println("len:", len(m)) 复制代码内建的 delete 可以从一个 map 中移除键值对
delete(m, "k") 复制代码
当从一个 map 中取值时，可选的第二返回值指示这个键是在这个 map 中。这可以用来消除键不存在和键有零值，像 0 或者 "" 而产生的歧义。
val, ok := m["k"] fmt.Println("val:", val) 复制代码如果想更深入了解map实现原理的同学，可查看我得这篇小结 Array、Slice、Map原理浅析
func
使用关键字 func 定义函数
func test(a, b int) int { return a + b } 复制代码其中，有返回值的函数，必须有明确的终止语句，否则会引发编译错误。
函数是可变参的，变参的本质上是slice，只能有一个，且必须是最后一个，如
func test(s string, n ...int) string { var x int for _, i := range n { x += i } return fmt.Sprintf(s, x) } 复制代码Golang 函数支持多返回值。这个特性在 Go 语言中经常被用到，例如用来同时返回一个函数的结果和错误信息。
func vals() (int, int) { return 3, 7 } 复制代码return && defer
defer用于资源的释放，会在函数返回之前进行调用。一般采用如下模式：
func test() { f, err := os.Open(filename) if err != nil { panic(err) } defer f.Close() } 复制代码如果有多个defer表达式，调用顺序类似于栈，越后面的defer表达式越先被调用，即后入先出的规则。
func test() { defer fmt.Println(1) defer fmt.Println(2) } 复制代码输出结果为
2 1 复制代码
为了更深刻理解 defer 和 return 下面我们先来看几个例子。
例1：
func f() (result int) { defer func() { result++ }() return 0 } 复制代码例2：
func f() (r int) { t := 5 defer func() { t = t + 5 }() return t } 复制代码例3：
func f() (r int) { defer func(r int) { r = r + 5 }(r) return 1 } 复制代码函数返回的过程是这样的：先给返回值赋值，然后调用defer表达式，最后才是返回到调用函数中。
defer表达式可能会在设置函数返回值之后，在返回到调用函数之前，修改返回值，使最终的函数返回值与你想象的不一致。
其实使用defer时，用一个简单的转换规则改写一下，就不会迷糊了。改写规则是将return语句拆成两句写，return xxx会被改写成:
返回值 = xxx 调用defer函数 空的return 复制代码
下面我们针对上面的三个例子分析，先看例1，它可以改写成这样：
func f() (result int) { result = 0 //return语句不是一条原子调用，return xxx其实是赋值＋ret指令 func() { //defer被插入到return之前执行，也就是赋返回值和ret指令之间 result++ }() return } 复制代码所以这个返回值是1。
例2，它可以改写成这样：
func f() (r int) { t := 5 r = t //赋值指令 func() { //defer被插入到赋值与返回之间执行，这个例子中返回值r没被修改过 t = t + 5 } return //空的return指令 } 复制代码所以这个返回值是5。
例3，它可以改写成这样：
func f() (r int) { r = 1 //给返回值赋值 func(r int) { //这里改的r是传值传进去的r，不会改变要返回的那个r值 r = r + 5 }(r) return //空的return } 复制代码所以这个返回值是1。
defer确实是在return之前调用的。但表现形式上却可能不像。本质原因是return xxx语句并不是一条原子指令，defer被插入到了赋值 与 ret之间，因此可能有机会改变最终的返回值。
goroutine的控制结构中，有一张表记录defer，调用runtime.deferproc时会将需要defer的表达式记录在表中，而在调用runtime.deferreturn的时候，则会依次从defer表中出栈并执行。
type
type是go语法里的重要而且常用的关键字，其主要作用就是用来定义类型。
定义结构体
type Person struct { name string } 复制代码类型等价定义，相当于类型重命名
type name string func main() { var myname name = "golang" //其实就是字符串类型 fmt.Println(myname) } 复制代码定义接口
type Person interface { Run() } 复制代码struct
Go 的结构体 是各个字段字段的类型的集合。是值类型，赋值和传参会赋值全部内容。
struct的基本用法
type Person struct { Name string Age int } func main() { p := Person{ Name: "ck", Age: 20, } p.Age = 25 fmt.Println(p) } 复制代码顺序初始化必须包含全部字段。否则会报错
type Person struct { Name string Age int } func main() { p1 := Person{"ck", 20} p2 := Person{"ck"} // Error: too few values in struct initializer } 复制代码支持匿名结构，可用作结构成员或定义变量
type Person struct { Name string Attr struct{ age int } } 复制代码支持 "=="、"!=" 相等操作符，可用作 map 键类型。
type Person struct { Name string } m := map[Person]int{ Person{"ck"}: 10, } 复制代码struct 支持嵌入式结构，可以像普通字段那样访问匿名字段成员，如下
type Person struct { Name string } type User struct { Person Age int } func main() { u := User{ Person: Person{ Name: "ck", }, Age: 22, } fmt.Println(u.Name) // ck } 复制代码当被嵌入结构中的某个字段与当前struct中已存在的字段同名时，编译器从外向内逐级查找所有层次的匿名字段，直到发现目标或者报错。
type Person struct { Age int } type User struct { Person Age int } func main() { u := User{ Person: Person{ Age: 20, }, Age: 22, } fmt.Println(u.Age) // 22 } 复制代码如果想访问被嵌入结构Person中的Age
fmt.Println(u.Person.Age) // 20 复制代码
interface
首先 interface 是一种类型，从它的定义可以看出来用了 type 关键字，更准确的说 interface 是一种具有一组方法的类型，这些方法定义了 interface 的行为。
如果一个类型实现了一个 interface 中所有方法，我们说类型实现了该 interface，所以所有类型都实现了 empty interface，因为任何一种类型至少实现了 0 个方法。go 没有显式的关键字用来实现 interface，只需要实现 interface 包含的方法即可。
接口定义与基本操作
type Dog interface { Category() } type Ha struct { Name string } func (h Ha) Category() { fmt.Println("狗子") } func main() { h := Ha{"二哈"} h.Category() test(h) } func test(a Dog) { fmt.Println("成功调用啦") } // 输出结果为：狗子 成功调用啦 复制代码上述代码中可以看到，对于 test 函数接收的参数类型为 Dog 这个类型，我们传入的是 Ha 类型的h，该函数正常运行并输出了结果，说明 Ha 类型已经成功实现了 Dog 。
嵌入结构
当我们需要使用复杂结构关系的时候，我们就会需要用到嵌入接口。接下来，我们将上述例子修改一下，如下所示
type Dog interface { Animal } type Animal interface { Category() } type Ha struct { Name string } func (h Ha) Category() { fmt.Println("狗子") } func main() { h := Ha{"二哈"} h.Category() test(h) } func test(a Dog) { fmt.Println("成功调用啦") } // 输出结果为：狗子 成功调用啦 复制代码可以看到，程序同样正常运行，这也就证明了我们成功是实现了嵌入接口。
类型断言
一个 interface 被多种类型实现时，有时候我们需要区分 interface 的变量究竟存储哪种类型的值。
go 可以使用 comma, ok 的形式做区分 value, ok := em.(T)：em 是 interface 类型的变量，T代表要断言的类型，value 是 interface 变量存储的值，ok 是 bool 类型表示是否为该断言的类型 T。。
type Dog interface { Animal } type Animal interface { Category() } type Ha struct { Name string } func (h Ha) Category() { fmt.Println("狗子") } func main() { h := Ha{"二哈"} h.Category() test(h) } func test(a Dog) { if v, ok := a.(Ha); ok { fmt.Println(v.Name) } } // 输出结果为：狗子 二哈 复制代码如果需要区分多种类型，可以使用 switch 断言，更简单直接，这种断言方式只能在 switch 语句中使用。
type Dog interface { Animal } type Animal interface { Category() } type Ha struct { Name string } func (h Ha) Category() { fmt.Println("狗子") } func main() { h := Ha{"二哈"} h.Category() test(h) } func test(a Dog) { switch v := a.(type) { case Ha: fmt.Println(v.Name) default: fmt.Println("暂未匹配到该类型") } } // 输出结果为：狗子 二哈 复制代码空接口
空接口 interface{} 没有任何方法签名，也就意味着任何类型都实现了空接口。其作用类似于面向对象语言中的根对象 Object 。
func Print(v interface{}) { fmt.Println(v) } func main() { Print(1) Print("Hello, World") } // 输出结果为：1 Hello, World 复制代码既然空的 interface 可以接受任何类型的参数，那么一个 interface{}类型的 slice 是不是就可以接受任何类型的 slice ?
func printAll(vals []interface{}) { //1 for _, val := range vals { fmt.Println(val) } } func main(){ names := []string{"stanley", "david", "oscar"} printAll(names) } 复制代码执行之后竟然会报 cannot use names (type []string) as type []interface {} in argument to printAll 错误，why？
这个错误说明 go 没有帮助我们自动把 slice 转换成 interface{} 类型的 slice，所以出错了。go 不会对 类型是interface{} 的 slice 进行转换 。
但是我们可以手动进行转换来达到我们的目的。
var dataSlice []int = foo() var interfaceSlice []interface{} = make([]interface{}, len(dataSlice)) for i, d := range dataSlice { interfaceSlice[i] = d } 复制代码有个坑需要注意
如果是按 pointer 调用，go 会自动进行转换，因为有了指针总是能得到指针指向的值是什么，如果是 value 调用，go 将无从得知 value 的原始值是什么，因为 value 是份拷贝。go 会把指针进行隐式转换得到 value，但反过来则不行。
for
for 是 Go 中唯一的循环结构。这里有 for 循环的三个基本使用方式。
最常用的方式，带单个循环条件
i := 1 for i <= 3 { fmt.Println(i) i = i + 1 } 复制代码经典的初始化/条件/后续形式 for 循环
for j := 7; j <= 9; j++ { fmt.Println(j) } 复制代码不带条件的 for 循环将一直执行，直到在循环体内使用了 break 或者 return 来跳出循环。
for { fmt.Println("loop") break } 复制代码if else
golang 中 if 要注意的点是
可省略条件表达式的括号。
支持初始化语句，可定义代码块局部变量。
代码块左大括号必须在条件表达式尾部。
不支持三元操作符 "a > b ? a : b"
if num := 9; num < 0 { fmt.Println(num, "is negative") } else if num < 10 { fmt.Println(num, "has 1 digit") } else { fmt.Println(num, "has multiple digits") } 复制代码switch case default
switch sExpr { case expr1: some instructions case expr2: some other instructions case expr3: some other instructions default: other code } 复制代码sExpr和expr1、expr2、expr3的类型必须一致。Go的switch非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；而如果switch没有表达式，它会匹配true。 Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch
fallthrough
在switch中，使用fallthrough可以强制执行后面的case代码。
switch sExpr { case false: fmt.Println("The integer was <= 4") fallthrough case true: fmt.Println("The integer was <= 5") fallthrough case false: fmt.Println("The integer was <= 6") fallthrough case true: fmt.Println("The integer was <= 7") case false: fmt.Println("The integer was <= 8") fallthrough default: fmt.Println("default case") } } 复制代码输出
The integer was <= 5 The integer was <= 6 The integer was <= 7 复制代码
for break continue goto range
for 是 Go 中唯一的循环结构。这里有 for 循环的三个基本使用方式。
最常用的方式，带单个循环条件。
i := 1 for i <= 3 { fmt.Println(i) i = i + 1 } 复制代码经典的初始化/条件/后续形式 for 循环。
for j := 7; j <= 9; j++ { fmt.Println(j) } 复制代码不带条件的 for 循环将一直执行，直到在循环体内使用了 break 或者 return 来跳出循环。
for { fmt.Println("loop") break } 复制代码break是跳出本次循环，continue是跳过该次循环，继续下次循环。
go
轻松开启高并发，一直都是golang语言引以为豪的功能点。golang通过goroutine实现高并发，而开启goroutine的钥匙正是go关键字。开启并发执行的语法格式是：
go funcName() 复制代码
select
Go的select关键字可以让你同时等待多个通道操作，将协程（goroutine），通道（channel）和select结合起来构成了Go的一个强大特性。
package main import "time" import "fmt" func main() { // 本例中，我们从两个通道中选择 c1 := make(chan string) c2 := make(chan string) // 为了模拟并行协程的阻塞操作，我们让每个通道在一段时间后再写入一个值 go func() { time.Sleep(time.Second * 1) c1 <- "one" }() go func() { time.Sleep(time.Second * 2) c2 <- "two" }() // 我们使用select来等待这两个通道的值，然后输出 for i := 0; i < 2; i++ { select { case msg1 := <-c1: fmt.Println("received", msg1) case msg2 := <-c2: fmt.Println("received", msg2) } } } 复制代码输出结果
received one received two 复制代码
如我们所期望的，程序输出了正确的值。对于select语句而言，它不断地检测通道是否有值过来，一旦发现有值过来，立刻获取输出。
chan
channel[通道]是golang的一种重要特性，正是因为channel的存在才使得golang不同于其它语言。channel使得并发编程变得简单容易有趣。
一个channel可以理解为一个先进先出的消息队列。如下图所示:
创建channel有以下几种 方式，
var ch chan string; // nil channel ch := make(chan string); // zero channel ch := make(chan string, 10); // buffered channel 复制代码
channel里面的value buffer的容量也就是channel的容量。channel的容量为零表示这是一个阻塞型通道，非零表示缓冲型通道[非阻塞型通道]。
但是，这里有个坑，当channel的容量为0时，for循环一次开10个goroutine打印输出，此时理论上应该是顺序输出的，但是确实无序输出的，这是因为现在的 Go 默认就是启用的多核，不像以前版本还需要手动设置使用多核。
随时随地看视频
