内置函数+递归+闭包

内置函数

close

主要用来关闭channel

len

用来求长度，比如string，array，slice，map，channel

new

用来分配内存，主要用来分配值的类型，比如int、struct，返回的是指针

var i int
fmt.Println(i)   // 返回0
j := new(int)
fmt.Println(j)    // 返回一个地址
// 赋值
*j = 100

make

用来分配内存，主要分配引用类型，比如chan、map、slice

// new出来的是一个指针，指向切片的地址
s1 := new([]int)
fmt.Println(s1)		// 返回一个地址

// make出来的就直接是切片
s2 := make([]int, 10)   // 第二个参数指定切片的长度
fmt.Println(s2)    // 返回切片的值

// 赋值
*s1 = make([]int, 5)
(*s1)[0] = 10
s2[0] = 10

append

用来追加元素到数组、slice中

var a []int   // 定义切片，括号里面声明长度是数组，没有声明是切片
a = append(a, 10, 20, 30)

// 将切片添加
a = append(a, a)  // 这样是不可以的，需要将后面的a展开
a = append(a, a...)

panic和recover

用来做错误处理

func test() {
	defer func() {
    	if err := recover(); err != nil {
        	fmt.Println(err)
    	}
	}()

	b := 0
    a := 100 / b   // recover()捕获这里的异常
	return 
}


// 自己抛异常
func initConfig() (err error) {
    return errors.New("init config failed")   // errors包
}

func test() {
    err := initConfig()
    if err != nil {
        panic(err)    // 抛出异常
    }
}

递归函数

一个函数调用自己，就叫做递归

func calc(n int) int {
    if n == 1 {
        return 1
    }
    return calc(n - 1) * n
}

递归的设计原则

• 一个大的问题能够分解成相似的小问题

• 定义好出口条件

闭包

一个函数和与其相关的引用环绕组合而成的实体

func Adder() func(int) int {
    var x int
    return func(delta int) int {
        x += delta
        return x
    }
}


func main() {
    var f = Adder()
    f(1)   // 1
    f(100)  // 101
    f(1000)  // 1101
}

// 由此可见，闭包中的变量状态会一直保存