go标准库之builtin模块

这个包提供了以下类型声明、变量和常量声明，还有一些便利函数，这个包不需要导入，这些变量和函数就可以直接使用

常用函数

append

给切片动态添加数据

// append
func test1() {
	s := []int{1, 2, 3}
	i := append(s, 100)
	fmt.Printf("i: %v\n", i) // i: [1 2 3 100]
	s1 := []int{4, 5, 6}
	i2 := append(s, s1...)     // 将s1解构
	fmt.Printf("i2: %v\n", i2) // i2: [1 2 3 4 5 6]
}

len

获取切片、字符串长度

// len
func test2() {
	s := "Hello World"
	fmt.Printf("len(s): %v\n", len(s)) // len(s): 11
	s1 := []int{1, 2, 3}
	fmt.Printf("len(s1): %v\n", len(s1)) // len(s1): 3
}

print和println

直接打印

// print和println
func test3() {
	name := "tom"
	age := 20
	print(name, " ", age, "\n")
	fmt.Println("------------")
	println(name, " ", age)
}

panic

func test4() {
	// 抛出异常
	defer fmt.Println("panic后 我还会执行...")
	panic("哎呀 完蛋了...")
	fmt.Println("end...") // 不会输出
}

new和make

new 和 make 区别:

1. make 只能用来分配及初始化类型为 slice ， map ，chan 的数据； new 可以分配任意类型的数据
2. new 分配返回的是指针，即类型 *T ；make 返回引用，即 T
3. new 分配的空间被清零， make 分配后，会进行初始化

new

func test5() {
	b := new(bool)
	fmt.Printf("b: %T\n", b)  // b: *bool
	fmt.Printf("b: %v\n", b)  // b: 0xc00000a098
	fmt.Printf("b: %v\n", *b) // b: false

	i := new(int)
	fmt.Printf("i: %T\n", i)  // i: *int
	fmt.Printf("i: %v\n", i)  // i: 0xc00000a0b8
	fmt.Printf("i: %v\n", *i) // i: 0

	s := new(string)
	fmt.Printf("s: %T\n", s)  // s: *string
	fmt.Printf("s: %v\n", s)  // s: 0xc000050260
	fmt.Printf("s: %v\n", *s) // s:
}

make

内建函数 make(T,args) 与 new(T) 的用途不一样，它只会用来创建 slice ， map 和 channel ，并且返回一个初始化的(而不是置0)，类型为 T 的值(而不是 *T)，之所以不同描述一位这三个类型背后引用了使用前必须初始化的数据结构。例如：slice 是一个三元描述符，包含指向数据（在数组中）的指针，长度及3容量，在这些项被初始化之前， slice 都是 nil 。对于 slice ， map 和 channel , make 初始化这些内部数据结构，并准备好用的值

分配一个有 100 个 int 的数组，然后创建一个长度为 10 ，容量为 100 的 slice 结构，改 slice 引用包含前 10 个元素的数组。对应的， new([]int) 返回一个指向新分配的，被置0的 slice 结构体指针，即指向值为 nil 的 slice 的指针

make([]int, 10, 100)

func main() {
	var p *[]int = new([]int)
	fmt.Printf("p: %v\n", p) // p: &[]
	v := make([]int, 10)
	fmt.Printf("v: %v\n", v) // v: [0 0 0 0 0 0 0 0 0 0]
}