Go内建方法

1 make

• 1 创建 slice、map、chan
• 2 返回引用类型

slice： 切片，类似数组，但是切片是可以扩容的
map：与java语言的map类似，键值对
chan：管道，用于两个线程之间的数据通信

chan和slice的数据类型后的数字意义是不同的,一个是数组的数量,一个是缓存的数量

代码示例

// 创建切片
func makeSlice()  {
	mSlice := make([]string, 3)
	mSlice[0] = "fulin.tang"
	mSlice[1] = "yanxu.long"
	mSlice[2] = "leyan.tang"
	fmt.Println(mSlice);
}

// 创建map
func makeMap()  {
	mMap := make(map[int]string)
	mMap[10] = "fulin.tang"
	mMap[100] = "yanxu.long"
	fmt.Println(mMap)
}

// 创建缓存为3的chan
func makeChan()  {
	// 这里第二个参数并不是长度，而是缓存可以是3，也就是管道容量
	// 如果不带该参数，那么就是创建一个不带缓存的管道
	mChan := make(chan int, 3)
	close(mChan)
}

2 new

• 内存置零
• 返回传入类型的指针地址

代码示例

// netMap类型数据
func newMap()  {
	mNewMap := new(map[int]string)
	mMakeMap := make(map[int]string)
	fmt.Println("mNewMap", reflect.TypeOf(mNewMap))
	fmt.Println("mMakeMap", reflect.TypeOf(mMakeMap))
}

打印结果

mNewMap *map[int]string
mMakeMap map[int]string

3 append & delete & copy

• slice => append & copy

• map => delete

3.1 append

// 切片append
func appendElementForSlice()  {
	mIDSlice := make([]string, 2)
	mIDSlice[0] = "id-1"
	mIDSlice[1] = "id-2"
	fmt.Println("len=", len(mIDSlice))
	fmt.Println("cap=", cap(mIDSlice))
	mIDSlice = append(mIDSlice, "id-3")
	fmt.Println(mIDSlice)
	fmt.Println("After len=", len(mIDSlice))
	fmt.Println("After cap=", cap(mIDSlice))
}

len= 2
cap= 2
[id-1 id-2 id-3]
After len= 3 //长度
After cap= 4 //容量

性能需求高时，切片的容量尽量确认，减少不必要的内存分配步骤

3.2 copy

等长时

// 拷贝切片
func copyForSlice()  {
	mIDSliceDst := make([]string, 2)
	mIDSliceDst[0] = "id-dst-1"
	mIDSliceDst[1] = "id-dst-2"
    
	mIDSliceSrc := make([]string, 2)
	mIDSliceSrc[0] = "id-src-1"
	mIDSliceSrc[1] = "id-src-2"
    
	copy(mIDSliceDst, mIDSliceSrc)
	fmt.Println(mIDSliceDst)
}

全部拷贝

[id-src-1 id-src-2]

源小于目标时

// 拷贝切片
func copyForSlice()  {
	mIDSliceDst := make([]string, 3)
	mIDSliceDst[0] = "id-dst-1"
	mIDSliceDst[1] = "id-dst-2"
	mIDSliceDst[2] = "id-dst-3"

	mIDSliceSrc := make([]string, 2)
	mIDSliceSrc[0] = "id-src-1"
	mIDSliceSrc[1] = "id-src-2"

	copy(mIDSliceDst, mIDSliceSrc)
	fmt.Println(mIDSliceDst)
}

只拷贝源长度的数据，超出部分不拷贝

[id-src-1 id-src-2 id-dst-3]

源长度大于目标时

// 拷贝切片
func copyForSlice()  {
	mIDSliceDst := make([]string, 2)
	mIDSliceDst[0] = "id-dst-1"
	mIDSliceDst[1] = "id-dst-2"

	mIDSliceSrc := make([]string, 3)
	mIDSliceSrc[0] = "id-src-1"
	mIDSliceSrc[1] = "id-src-2"
	mIDSliceSrc[2] = "id-src-3"

	copy(mIDSliceDst, mIDSliceSrc)
	fmt.Println(mIDSliceDst)
}

只会拷贝目标长度的数据

[id-src-1 id-src-2]

3.3 delete

func deleteForMap()  {
	mIdMap := make(map[int]string)
	mIdMap[0] = "id-1"
	mIdMap[1] = "id-2"
	delete(mIdMap, 0)
	fmt.Println(mIdMap)
}

可以看到删除了对应数据

map[1:id-2]

4 panic & recover

处理异常

• panic 抛出异常
• recover 捕获异常

4.1 内部类

代码示例

func receivePanic()  {
	defer func() {
		message := recover()
		fmt.Println("panic message:", message)
	}()
	panic("I am a panic");
}

输出

panic message: I am a panic

4.2 封装方式

func receivePanic()  {
	defer coverPanic()
	panic("I am a panic");
}

func coverPanic()  {
	message := recover();
	switch message.(type) {
	case string:
		fmt.Println("string message:", message)
	case error:
		fmt.Println("error message:", message)
	default:
		fmt.Println("unknown panic:", message)
	}
}

string message: I am a panic

5 len & cap & close

• len => string、 array、 slice、 map、 chan
• cap => slice、 array、 chan
• close => chan

5.1 len & cap

// 测试长度和容量
func getLenCap()  {
	// make(类型，长度，容量)
	mSlice := make([]string, 3, 5)
	mSlice[0] = "fulin.tang"
	mSlice[1] = "yanxu.long"
	mSlice[2] = "leyan.tang"
	mSlice = append(mSlice, "zhong.fu")
	fmt.Println("slice len: ", len(mSlice))
	fmt.Println("slice cap: ", cap(mSlice))
}

slice len:  4
slice cap:  5

5.2 close

// 关闭chan，关闭后就不能往里写数据了，可以控制一些业务
func closeChan()  {
	mChan := make(chan int, 1)
	defer close(mChan)
	mChan <- 1
	// 业务流程
}