inner_func.go

package main

import "fmt"

/*
内置函数:

	append          -- 用来追加元素到数组、slice中,返回修改后的数组、slice
	close           -- 主要用来关闭channel
	delete          -- 从map中删除key对应的value
	panic           -- 停止常规的goroutine  （panic和recover：用来做错误处理）
	recover         -- 允许程序定义goroutine的panic动作
	imag            -- 返回complex的实部   （complex、real imag：用于创建和操作复数）
	real            -- 返回complex的虚部
	make            -- 用来分配内存，返回Type本身(只能应用于slice, map, channel)
	new             -- 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
	cap             -- capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
	copy            -- 用于复制和连接slice，返回复制的数目
	len             -- 来求长度，比如string、array、slice、map、channel ，返回长度
	print、println   -- 底层打印函数，在部署环境中建议使用 fmt 包
*/
func innerFunc() {

	fmt.Println("=====内置函数=====")

	//slice 用来追加元素到数组、slice中,返回修改后的数组
	nums := []int{1, 2, 3, 4}
	nums = append(nums, 5, 6, 7, 8, 9, 10, 11)

	//close 主要用来关闭channel
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	close(ch)

	for v := range ch {
		fmt.Println(v)
	}

	//delete 从map中删除key对应的value
	m := map[string]int{"utils": 1, "b": 2, "c": 3}
	delete(m, "utils")
	fmt.Println(m)

	//recover 允许程序定义goroutine的panic动作
	defer func() { // 匿名函数延迟执行,在执行期间捕获到panic或执行完毕后调用
		if err := recover(); err != nil {
			fmt.Println("捕获到panic: ", err)
		}
		fmt.Println("程序执行完毕")
	}()

	//panic("出错了") //抛出panic异常,此行后面代码不再执行

	//imag 返回complex的虚部   （complex、real imag：用于创建和操作复数）
	c := complex(1, 3)
	fmt.Println(imag(c))

	//real 返回complex的虚部
	fmt.Println(real(c))

	//make 用来分配内存，返回Type本身(只能应用于slice)
	s := make([]int, 3) //长度为3的slice
	s[0] = 1

	//new 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
	p := new(int)
	*p = 2
	fmt.Println(p)

	//cap  capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
	fmt.Println(cap(nums))

	//copy 用于复制和连接slice，返回复制的数目
	src := []int{1, 2, 3, 4}
	dst := make([]int, 2)
	n := copy(dst, src)
	fmt.Println(dst, n)

	//len 来求长度，比如string、array、slice、map、channel ，返回长度
	fmt.Println(len(nums))

	//print、println   -- 底层打印函数，在部署环境中建议使用 fmt 包
	fmt.Println("hello world")

	anonymous := func(a int, b int) int {
		fmt.Println("匿名函数")
		return a + b
	}
	r := anonymous(1, 2)
	fmt.Println(r)

	//函数集合
	fns := [](func(x int) int){
		func(x int) int { return x + 1 },
		func(x int) int { return x + 2 },
	}
	fmt.Println(fns[0](100))

	//函数字段
	d := struct {
		fn func() string
	}{
		fn: func() string { return "Hello, World!" },
	}
	fmt.Println(d.fn())

	//函数通道
	fc := make(chan func() string, 2)
	fc <- func() string { return "Hello, World!" }
	println((<-fc)())

	//defer 延迟执行
	var whatever [5]struct{}
	for i, v := range whatever {
		defer fmt.Println(i, v)
	}

}