1、builtin标准库

1、builtin介绍

builtin 包为Go的预声明标识符提供了文档。此处列出的条目其实并不在builtin 包中，对它们的描述只是为了让 godoc 给该语言的特殊标识符提供文档。
这个包里面描述了类型以及内置函数，这些内置函数都是为了操作类型而设定的。虽然这是一个包但是并不需要导入这个包。

2、常量

详解常量

package main

import (
	"fmt"
)

// 常量
// 1、常量的定义和全局变量变量定义类似，只是把var改成了const
const (
	X = 1
	Y = 2
)

// 2、如果常量省略了值默认和上面一行(邻近的一行)的值是相同的，首行必须有值，因为他没有上一行可以推导出值
const (
	T1 = 10
	T2 = 19
	T3	//19
)

// 3、iota(类似枚举)

// const iota = 0 // 无类型整数值(系统定义)
// iota是一个预定义的标识符，代表顺序按行增加的无符号整数，每个const声明单元（被括号括起来）相互独立，分别从0开始。

// iota是go语言的常量计数器，只能在常量的表达式中使用。
// iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。
// 使用iota能简化定义，在定义枚举时很有用。
const (
	n1 = iota //0
	n2        //1
	n3        //2
	n4        //3
)

// 跳过
const (
	v1 = iota	// 0
	v2			// 1
	_			// 跳过
	v3			// 3
)

// 插入
const (
	b1 = iota
	b2 = 100
	b3		// 100 b2中间插入，此时b3的规则就是找上一条的值赋给自己
	b4		// 100
)

const (
	c1 = iota	// 0
	c2 = 100	// 100
	c3 = iota	// 2	// 接着上面的开始，c2相当于占了一个位置，所以这里是2
	c4			// 3
)

// 多个常量定义在一行，最好是每一行的个数相同，否则容易发生错误
// 这里有两列，且首行各自赋了iota，所以，每一列的常量都会累加
const (
	a, b = iota + 1, iota + 2 //1,2
	c, d                      //2,3
	e, f                      //3,4
)

// 为bool类型提供的两个系统常量，bool的值只能是true或false
const (
	true  = 0 == 0 // 无类型布尔值  --> 输出true时结果仍是true
	false = 0 != 0 // 无类型布尔值  --> 输出false时结果仍是false
)

3、new和make

/*
		new 和 make
		值类型、地址类型和引用类型

		值类型就是开辟在栈上的一块空间，在传递时就会拷贝一份新的不会影响到自身
		地址类型相对于值类型，它是地址的表示16进制，指向内存中的一块内存空间，这里面的是实际需要的数据

		引用类型，不同于上面两种，在go中的各种数据类型中，只有切片、map和信道是引用类型。
		引用类型的内存模型不同于上面两种，这种类型本身和其他数据类型别无二致，但是内部维护的数据更为复杂；

		
			切片、map和管道是多种数据复合而成的一种数据类型

			切片、map和管道是通过结构体将多种数据组合而成的。

			切片主要有三种数据 --> 指向一块内存数组地址的16进制地址 / 切片的长度(数据量) / 切片的容量(可以自动扩容)
			map和管道类似切片，一个指向数据的指针，以及容量等

			这三种数据本身是结构体(值类型)，所以一旦要对变量本身操作，就必须要是传地址的(*[]int、*map[string]string等函数参数)
			比如 将切片传递给函数参数，在函数里面通过内置函数的append会返回一个切片，如果将返回的切片赋值给本身，那么此时原来的切片和当前的就不一样了，除非通过地址传递

			make内置函数是给切片、映射、或通道初始化的，主要是对他们内部维护的内存地址开辟指定空间,如果make，这块地址是nil，无法操作
	*/

4、len和cap

func testCap() {

	//数组
	var array1 [3]int
	array1[0] = 100
	fmt.Println(cap(array1)) // 3

	// 数组指针
	var arrayPtr *[3]int = new([3]int)
	(*arrayPtr)[1] = 999
	fmt.Println(cap(arrayPtr)) // 3

	// 切片
	var slice []int = make([]int, 3, 6)
	slice[2] = 89
	fmt.Println(cap(slice)) // 6

	// 信道
	var channel chan int = make(chan int, 10)
	fmt.Println(cap(channel)) // 10

	var chann *chan int = new(chan int)
	fmt.Println(cap(*chann)) // 0
}

func testLen() {

	//数组
	var array1 [3]int
	array1[0] = 100
	fmt.Println(len(array1)) // 3

	// 数组指针
	var arrayPtr *[3]int = new([3]int)
	(*arrayPtr)[1] = 999
	fmt.Println(len(arrayPtr)) // 3

	// 切片
	var slice []int = make([]int, 3, 6)
	slice[2] = 89
	fmt.Println(len(slice)) // 3

	// 映射
	var mmp map[string]string = make(map[string]string, 3)
	mmp["name"] = "kiko"
	mmp["age"] = "23"
	fmt.Println(len(mmp)) // 2

	// 信道
	var channel chan int = make(chan int, 10)
	channel <- 10
	channel <- 30
	<-channel
	fmt.Println(len(channel)) // 1

	// 字符串
	str := "Hello"
	fmt.Println(len(str)) // 5

}

5、copy

copy函数针对的是切片类型的数据。拷贝之后的对象和原来的没有数据关联，改变其中一个不会影响另一个。

func testCopy() {

	var src []int = []int{1, 2, 3, 4}

	// 目标切片对象必须初始化
	var dst []int = make([]int, 3)

	n := copy(dst, src)

	fmt.Println(n)   // 3
	fmt.Println(src) // [1 2 3 4]
	fmt.Println(dst) // [1 2 3]
}

func testStr() {

	str := "hello world!"
	var dst []byte = make([]byte, len(str))

	// 字符串复制到字节切片中
	n := copy(dst, str)

	fmt.Println(n)   // 12
	fmt.Println(dst) // [104 101 108 108 111 32 119 111 114 108 100 33]
}

6、delete

delete函数根据键删除对应的键值对，针对map操作。

7、close

8、panic和recover

9、print和println