Golan中 new() 、 make() 和简短声明符的区别和使用

// 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

package main
import "fmt"
func main() {
    // 使用 new 创建一个 int 类型的指针
    p := new(int)
    // new 返回的是指向 int 的指针，指针的初始值是零值，即 0
    fmt.Println(*p)  // 输出: 0
    *p = 42  // 修改 p 指向的值
    fmt.Println(*p)  // 输出: 42
}

// 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

package main
import "fmt"
func main() {
    // 创建一个长度为 5 的整数切片
    slice := make([]int, 5)
    fmt.Println(slice)  // 输出: [0 0 0 0 0]
    // 创建一个长度为 3，容量为 5 的切片
    slice2 := make([]int, 3, 5)
    fmt.Println(slice2)  // 输出: [0 0 0]
    // 创建一个容量为 10 的整数通道
    ch := make(chan int, 10)
    ch <- 42  // 向通道中发送数据
    fmt.Println(<-ch)  // 输出: 42
    // 创建一个具有初始大小的映射
    m := make(map[string]int)
    m["key"] = 10
    fmt.Println(m)  // 输出: map[key:10]
}

package main
import "fmt"
func main() {
    // 使用 := 创建并初始化一个 map
    m := map[string]int{
        "apple":  5,
        "banana": 3,
        "orange": 2,
    }
    // 输出 map 中的元素
    fmt.Println(m) // 输出: map[apple:5 banana:3 orange:2]
}

package main
import "fmt"
func main() {
    var x int    // 声明一个变量 x，类型是 int，零值是 0
    fmt.Println(x)  // 输出 0
    // 后续赋值
    x = 10
    fmt.Println(x)  // 输出 10
}

package main
import "fmt"
func main() {
    var s []int  // 声明一个切片，零值是 nil
    fmt.Println(s)  // 输出: []
    // 后续使用 append 或其他方式进行初始化
    s = append(s, 1, 2, 3)
    fmt.Println(s)  // 输出: [1 2 3]
}

package main
import "fmt"
func main() {
    var m map[string]int  // 声明一个映射，零值是 nil
    fmt.Println(m)  // 输出: map[]
    // 后续初始化映射
    m = make(map[string]int)
    m["apple"] = 5
    m["banana"] = 3
    fmt.Println(m)  // 输出: map[apple:5 banana:3]
}

package main
import "fmt"
func main() {
    var ch chan int  // 声明一个通道，零值是 nil
    fmt.Println(ch)  // 输出: <nil>
    // 后续初始化通道
    ch = make(chan int, 3)
    ch <- 1
    fmt.Println(<-ch)  // 输出: 1
}