纳尼？Go中 int、make 等居然不是关键字
这是一个小白问题，有多少人知道 int 不是关键字？make 也不是关键字？
我们知道每种语言都有关键字和保留字的，而 go 以关键字少著称，只有25个
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
也就是说，我们常用的 make, cap, len不是关键字，就连基本数据类型 int, int64, float 也都不是。但是 C 语言中关键字可是非常多的
make 内置函数
package main
import "fmt"
func main(){
make := func() string {
return "hijacked"
}
int := make() // Completely OK, variable 'int' will be a string
fmt.Println(int) // Prints "hijacked"
}
这段代码 make 变量是一个闭包，返回一个字符串，而 int 变量类型是字符串。最后函数打印 hijacked. 显然这段代码很神经病，谁要这么写会被打死，但确是可以编译成功的
同时如果想继续用 make 创建 map, 或是用 int 声明变量就会报错。本质上 make, cap, len 都是 go 源码中的函数名，有点泛型的意思
// The make built-in function allocates and initializes an object of type
// slice, map, or chan (only). Like new, the first argument is a type, not a
// value. Unlike new, make's return type is the same as the type of its
// argument, not a pointer to it. The specification of the result depends on
// the type:
// Slice: The size specifies the length. The capacity of the slice is
// equal to its length. A second integer argument may be provided to
// specify a different capacity; it must be no smaller than the
// length. For example, make([]int, 0, 10) allocates an underlying array
// of size 10 and returns a slice of length 0 and capacity 10 that is
// backed by this underlying array.
// Map: An empty map is allocated with enough space to hold the
// specified number of elements. The size may be omitted, in which case
// a small starting size is allocated.
// Channel: The channel's buffer is initialized with the specified
// buffer capacity. If zero, or the size is omitted, the channel is
// unbuffered.
func make(t Type, size ...IntegerType) Type
func len(v Type) int
func cap(v Type) int
上面是 runtime 中对 make, len, cap 的函数定义，大家可以看注释或是看 builtin.go. make 接收三种类型参数：Map, Channel, Slice. 返回值是类型 T, 而不像 new 返回的是指针 *T
也就是说，变量名用 make, 只是在 main 函数这个词法块中普通的局部变量而己，同时遮蔽了 runtime 的 make 函数名
Predeclared identifiers
前面说的是 make, 那么对于 int 呢？其实道理也一样，这些都是 go 预定义的标识符 Predeclared identifiers
Types:
bool byte complex64 complex128 error float32 float64
int int8 int16 int32 int64 rune string
uint uint8 uint16 uint32 uint64 uintptr
Constants:
true false iota
Zero value:
nil
Functions:
append cap close complex copy delete imag len
make new panic print println real recover
其实这些都 document 在 builtin.go，包括常见的整数类型，true, false, iota, nil 以及常用的函数 make, new, copy 等等，这些在其它语言可能都对应着关键词 keywords 或是保留词
从编译原理的角度看，identifiers 和 keywords 关键词没有本质的区别，都是一个一个 token 而己
官方告诉我们，这些预定义的标识符在 universe block 块中都是隐式定义的，所以我们才能直接用。那么什么是 universe block 呢？
Block = "{" StatementList "}" .
StatementList = { Statement ";" } .
除了上面这种显示的语句块，还有很多隐式的语句块。大家要小心，因为很多时候 variable shadow 就是因为这个隐式的
The universe block encompasses all Go source text. 通用块包括 go 源码文本
Each package has a package block containing all Go source text for that package. 每个包都有一个块，包含该包的所有 Go 源代码
Each file has a file block containing all Go source text in that file. 每个文件都有一个文件块，包含该文件中的所有 Go 源码
Each "if", "for", and "switch" statement is considered to be in its own implicit block. 每个
if、for和switch语句都被认为是在自己的隐式块中Each clause in a "switch" or "select" statement acts as an implicit block.
switch或select语句中的每个子句都是一个隐式块
我们就犯过错误，命中了最后一条导致了变量 shadow. 那么问题来了，为什么 go 选择预定义标识符的方式，而不是直接定义成 keywords 呢？Go prefers the universal block over keywords because declarations can be added to the universal block without breaking existing programs
⬇⬇⬇