// 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 創(chuàng)建一個 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() {
    // 創(chuàng)建一個長度為 5 的整數(shù)切片
    slice := make([]int, 5)
    fmt.Println(slice)  // 輸出: [0 0 0 0 0]
    // 創(chuàng)建一個長度為 3，容量為 5 的切片
    slice2 := make([]int, 3, 5)
    fmt.Println(slice2)  // 輸出: [0 0 0]
    // 創(chuàng)建一個容量為 10 的整數(shù)通道
    ch := make(chan int, 10)
    ch <- 42  // 向通道中發(fā)送數(shù)據(jù)
    fmt.Println(<-ch)  // 輸出: 42
    // 創(chuàng)建一個具有初始大小的映射
    m := make(map[string]int)
    m["key"] = 10
    fmt.Println(m)  // 輸出: map[key:10]
}

package main
import "fmt"
func main() {
    // 使用 := 創(chuàng)建并初始化一個 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ù)賦值
    x = 10
    fmt.Println(x)  // 輸出 10
}

package main
import "fmt"
func main() {
    var s []int  // 聲明一個切片，零值是 nil
    fmt.Println(s)  // 輸出: []
    // 后續(xù)使用 append 或其他方式進(jìn)行初始化
    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[]
    // 后續(xù)初始化映射
    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>
    // 后續(xù)初始化通道
    ch = make(chan int, 3)
    ch <- 1
    fmt.Println(<-ch)  // 輸出: 1
}