go语言new和make

1.new

func new(Type) *Type

内建函数，内建函数 new 用来分配内存，它的第一个参数是一个类型，它的返回值是一个指向新分配类型默认值的指针！

2.make

func make(Type, size IntegerType) Type

内建函数 make 用来为 slice，map 或 chan 类型分配内存和初始化一个对象(注意：只能用在这三种类型上)，跟 new 类似，第一个参数是一个类型，跟 new 不同的是，make 返回类型的引用而不是指针，而返回值也依赖于具体传入的类型

Slice: 第二个参数 size 指定了它的长度，它的容量和长度，你可以传入第三个参数来指定不同的容量值，但必须不能比长度值小。

比如 make([]int, 0, 10)

***尤其注意append切片时，如果长度和容量指定一个数，那么追加后则在末尾，并不在首部，看下面实例

package main

import "fmt"

func main() {
        // 追加到了末尾
        mkSlice = append(mkSlice, 10)
        fmt.Println(mkSlice)

        // make切片 并追加到切片头部
        // 那么需要把长度设为0，即没有切片内容
        //  长度为0，容量为5
        mkSlice2 := make([]int, 0, 5)
        fmt.Println(mkSlice2)

        // 追加到了末尾
        mkSlice2 = append(mkSlice2, 10)
        fmt.Println(mkSlice2)
}

结果：

[0 0 0 0 0]
[0 0 0 0 0 10]
[]
[10]

其他切片案例使用

package main

import "fmt"

func main() {
        //s1 := make([]int, 5, 6)
        //fmt.Println(s1)
        //fmt.Println(len(s1))
        //fmt.Println(cap(s1))

        // 数组
        s2 := [3]int{1, 2, 3}
        s3 := s2 // 赋值 ，内存不同
        fmt.Println(s2, s3)
        fmt.Printf("%p\n", &s2)
        fmt.Printf("%p\n", &s3)
        fmt.Println(s2 == s3) // 注意区别，值比较
        s2[0] = 1000
        fmt.Println(s2, s3) //[1000 2 3] [1 2 3]

        fmt.Println(&s2 == &s3) // 注意区别，取得的是地址
        fmt.Printf("%v\n", s2)
        fmt.Printf("%v\n", s3)
        fmt.Println("==================")

        // 切片
        s4 := []int{1, 2, 3}
        s5 := s4 // 引用s4里的值指向一个地方
        fmt.Println(s4, s5)
        s4[0] = 1000
        fmt.Println(s4, s5) //[1000 2 3] [1000 2 3]

        fmt.Println(&s4 == &s5) // 注意区别，取得的是变量的地址
        fmt.Printf("%p\n", s4)
        fmt.Printf("%p\n", s5)

        fmt.Println("===============")
        //test()

        fmt.Printf("\n", )

        // make切片
        mkSlice := make([]int, 5)
        fmt.Println(mkSlice)

        // 追加到了末尾
        mkSlice = append(mkSlice, 10)
        fmt.Println(mkSlice)

        // make切片 并追加到切片头部
        // 那么需要把长度设为0，即没有切片内容
        //  长度为0，容量为5
        mkSlice2 := make([]int, 0, 5)
        fmt.Println(mkSlice2)

        // 追加到了末尾
        mkSlice2 = append(mkSlice2, 10)
        fmt.Println(mkSlice2)

}

func test() {
        slice0 := []string{"a", "b", "c", "d", "e"}
        fmt.Println("\n~~~~~~元素遍历~~~~~~")
        for _, ele := range slice0 {
                fmt.Print(ele, "-")
                ele = "7" // ele值改变不了切片中的值
        }

        fmt.Println("\n========")
        fmt.Println(slice0)

        fmt.Println("\n~~~~~~索引遍历~~~~~~")
        for index := range slice0 {
                fmt.Print(slice0[index], " ")
        }
        fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")
        for index, ele := range slice0 {
                fmt.Print(ele, "-", slice0[index], " ")
        }
        fmt.Println("\n~~~~~~修改~~~~~~")
        for index := range slice0 {
                slice0[index] = "9"
        }
        fmt.Println(slice0)
}

Map: 根据 size 大小来初始化分配内存，不过分配后的 map 长度为 0，如果 size 被忽略了，那么会在初始化分配内存时分配一个小尺寸的内存

map案例

package main

import "fmt"

func main() {
        //// 随机数种子
        //rand.Seed(time.Now().UnixNano())
        //
        //scoreMap := make(map[string]int, 200)
        //for i := 0; i < 100; i++ {
        //      key := fmt.Sprintf("student%02d", i)
        //      scoreMap[key] = rand.Intn(100)
        //}
        //
        //fmt.Println(scoreMap)
        //
        //// 排序map的key
        //// 按字符串排序
        //keys := make([]string, 0, 100)
        //for key := range scoreMap {
        //      keys = append(keys, key)
        //}
        //
        //sort.Strings(keys)
        //// 打印
        //for _, key := range keys {
        //      fmt.Println(key, scoreMap[key])
        //}
        var mapSlice = make([]map[string]string, 1, 3)
        for index, value := range mapSlice {
                fmt.Printf("===index:%d value:%v\n", index, value)
        }

    // 初始化
        cur := map[string]string{"name":"hahah","1212":"3333"}
        mapSlice = append(mapSlice, cur)
        for index, value := range mapSlice {
                fmt.Printf("!!!index:%d value:%v\n", index, value)
        }

        //fmt.Println("after init")
        //// 对切片中的map元素进行初始化
        //mapSlice[0] = make(map[string]string, 10)
        //mapSlice[0]["name"] = "jadeshu"
        //mapSlice[0]["password"] = "123456"
        //mapSlice[0]["address"] = "北京"
        //for index, value := range mapSlice {
        //      fmt.Printf("index:%d value:%v\n", index, value)
        //}

        //a := make([]int, 10)
        //fmt.Println(a)      //[0 0]
        //a[1] = 20
        //fmt.Println(a)
        //fmt.Println(len(a)) //2
        //fmt.Println(cap(a)) //10

        // 端口：【address,ip】
        //info := make(map[int]map[string]string, 3)
        //info[8080] = make(map[string]string,4)
        //info[8080]["address"] = "上海"
        //info[8080]["ip"] = "127.0.0.1"
        //info[6060] = make(map[string]string,4)
        //info[6060]["address"] = "北京"
        //info[6060]["ip"] = "192.168.0.101"
        //fmt.Println(info)
        //
        //testInfo:= &map[int]map[string]string{
        //      6000:{
        //              "address":"香港",
        //              "ip":"127.0.0.1",
        //      },
        //      7000:{
        //              "address":"武汉",
        //              "ip":"127.0.0.1",
        //      },
        //}
        //
        //fmt.Println(testInfo)

}

Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者忽略容量，管道是没有缓冲区的

总结

new 的作用是初始化一个指向类型的指针(*T)，make 的作用是为 slice，map 或 chan 初始化并返回引用(T)。