参考教程：
http://www.flysnow.org/2017/03/26/go-in-action-go-type.html
http://www.flysnow.org/2017/10/23/go-new-vs-make.html
1 变量的类型
想弄明白 make 和 new 的区别，首先要分清楚引用类型和值类型。
1.1 值类型
golang 中内置原始数据类型是值类型。比如int、float、string、bool。值类型是不可变的，所以对他们进行操作，一般会返回一个新创建的值。把这些值传递给函数时，其实创建的是一个值的副本。这一点在python中也是相同的。作为参数传递给函数的都是一个副本。
func main(){
s := "a"
modify(s)
fmt.Println(s)
}
func modify(s string)string{
s = "888888888"
}
因为修改值类型，生成的都是它的一个副本，所以值类型在多线程中是安全的。
1.2 引用类型
切片、map、接口、函数类型以及chan都是引用类型。引用类型的修改可以影响到任何引用到它的变量。
引用类型之所以可以引用，是因为我们在创建引用类型的变量，其实是一个标头值，标头值里包含一个指针，指向底层的数据结构，在函数中传递引用类型时，传递的是这个标头值的副本，它所指向的底层结构并没有被复制传递，这也是引用类型传递高效的原因。
func main(){
ages := map[string]int{"s":12}
modify(ages)
fmt.Println(ages)
}
func modify(m map[string]int){
m["s"] = 777
}
函数 modify 的修改，会影响 ages 的值。
1.3 结构类型
用 var 关键字声明一个结构体类型的变量。
type person struct{
age int
name string
}
// 声明
var p person
这种 var 声明的方式，会对结构体 person 里的数据类型默认初始化，也就是使用它们类型的零值。
函数传参是值传递，所以对于结构体来说也不例外，结构体传递的是其本身以及里面的值的拷贝。
type Person struct {
age int
name string
}
func modify(p Person){
p.age = 100000000000
}
func main(){
jim := Person{10,"jim"}
fmt.Println(jim)
modify(jim)
fmt.Println(jim)
}
以上的输出都是一样的，所以我们验证传递的是值的副本。如果上面的例子我们要修改 age 的值可以通过传递结构体的指针。
type Person struct {
age int
name string
}
// 我觉得这样比较好理解，*Person 是针对结构体实例的操作。（可以想想面向对象的语言，Python / Java）
func modify(p *Person){
p.age = 100000000000
}
func main(){
// jim 的类型是 Person
jim := Person{10,"jim"}
// var jim Person = Person{10, "jim"}
fmt.Println(jim)
// &jim 指向的是实例
modify(&jim)
// var h *Person = &jim
fmt.Println(jim)
// * 号在定义时使用，&在运算时使用。*这种类型在运算时映射的值是&
}
1.4 自定义类型
type Duration int64
Go是强类型语言，所以 int64 与 Duration不能直接赋值。
2 变量的声明
var i int
var s string
变量的声明可以通过 var 关键字，然后就可以在程序中使用了，var 声明的变量的值是他们默认的零值。
| 类型 | 默认零值 |
|---|---|
| int | 0 |
| string | "" |
| 引用类型 | nil |
对引用类型赋值。
*int，是声明一个值类型int的引用类型。
*i,是对值类型的引用类型进行运算。
func main(){
var i *int
*i = 10
fmt.Println(*i)
}
运行时的 paninc : runtime error: invalid memory address or nil pointer dereference
从这个提示中可以看出，对于引用类型的变量，我们不光是声明它，还要为它分配内存空间，否则我们的值放在哪去呢？这就是上面错误提示的原因。
对于值类型的声明则不需要，是因为已经默认帮我们分配好了，值类型都有一个默认零值。
要分配内存，就引出来今天的new 和 make。
new
func main(){
var i *int
i = new(int)
*i = 10
fmt.Println(*i)
}
看下 new 这个内置的函数
// The new built-in function allocates memory.The first argument is a type,not a value, and the value returned is a pointer to a newly allocated zero value of that type.
func new(Type) *Type
new 是一个分配内存的内置函数。new的参数是一个类型，new的返回值是一个指针。该指针指向参数的默认零值。
func main(){
// 这个u 是什么类型，*user, 为啥？因为new函数返回的是一个指向参数类型默认零值的指针啊。
// 这种方式和上文中 u := user{}, &u 的方式实际上是一样的。
u := new(user)
u.lock.Lock()
u.name = "sssssssss"
u.lock.Unlock()
fmt.Println(u)
}
type user struct {
lock sync.Mutex
name string
age int
}
这就是 new,它返回的永远是类型的指针，指向分配类型的内存地址。
make
make 也用于内存分配，但是和 new 不同，它只用于 chan / map 和 且切片的内存创建，而且它返回的类型就是这三个类型本身，而不是它们的指针类型。因为chan / map / 切片已经是引用类型了，所以没必要返回他们的指针了。
看一下 make 的文档
The make built-in function allocates and initializes an object of type slice, map, or chan (only).Like new,the 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, so make([]int,0,10) allocates a slice of length 0 and capacity 10.
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
make 只为 slice/ map/ chan 初始化，分配内存。
和new 类似，第一个参数必须是一个类型。和 new 不同的是，new 返回的是参数类型的指针，指针指向的该参数的默认零值。而make返回的是传入类型相同，并不是指针。因为 slice / map / chan 本身就是引用类型了。
