参考教程：
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，是声明一个值类型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 本身就是引用类型了。