递归函数
简单来说，递归就是函数自己调用自己。有2种实现方式，一种是直接在自己函数中调用自己，一种是间接在自己函数中调用的其他函数中调用了自己。
递归函数需要有边界条件、递归前进段、递归返回段
递归一定要有边界条件，当边界条件不满足时，递归前进；当边界条件满足时，递归返回
func fib(n int) int { a, b := 1, 1 if n <= 2 && n > 0 { return 1 } else if n <= 0 { return 0 } for i := 2; i < n; i++ { a, b = b, a+b } return b } // 递推公式变递归 func fib1(n int) int { switch { case n > 0 && n < 3: return 1 case n == 0: return 0 } return fib1(n-1) + fib1(n-2) } // 循环变递归，循环次数变成了函数调用次数 func fib2(a, b, n int) int { if n < 0 { panic("nagetive") } else if n == 0 { return 0 } else if n >= 3 { a, b = b, a+b return fib2(a, b, n-1) } else { return b } } func main() { for i := 0; i < 10; i++ { fmt.Println(fib(i), fib1(i), fib2(1, 1, i)) } }
斐波那契数列
在循环层次变成递归函数层次中，n相当于循环变量，b和a+b就是每次循环体中使用的值
递归效率
在上面3个斐波那契数列函数实现中，如果进行时间计算，会发现fib1()函数效率最低，因为其中进行了大量的重复计算，所以慢。fib2()函数采用了递归函数调用层次代替循环层次，效率还不错，和循环版效率差不多。 但是函数每次递归，都会有压栈，递归到最后还要销毁栈帧，也会有资源开销。
对上面fib1函数进行优化后：
func fib(n int) int { a, b := 1, 1 if n <= 2 && n > 0 { return 1 } else if n <= 0 { return 0 } for i := 2; i < n; i++ { a, b = b, a+b } return b } // 递推公式变递归 func fib1(n int) int { switch { case n > 0 && n < 3: return 1 case n == 0: return 0 } return fib1(n-1) + fib1(n-2) } func fib11(n int, m map[int]int) int { switch { case n > 0 && n < 3: return 1 case n == 0: return 0 } // 查询map中是否已存在 v, ok := m[n] if ok { return v } else { v = fib11(n-1, m) + fib11(n-2, m) m[n] = v return v } } func fib12(n int, s []int) int { switch { case n > 0 && n < 3: return 1 case n == 0: return 0 } // 查询map中是否已存在 if s[n] != 0 { return s[n] } else { s[n] = fib12(n-1, s) + fib12(n-2, s) return s[n] } } // 循环变递归，循环次数变成了函数调用次数 func fib2(a, b, n int) int { if n < 0 { panic("nagetive") } else if n == 0 { return 0 } else if n >= 3 { a, b = b, a+b return fib2(a, b, n-1) } else { return b } } func main() { num := 100000 start_time := time.Now() dig := fib(num) end_time := time.Now() fmt.Printf("%v fib函数用时: %v\n", dig, end_time.Sub(start_time)) // start_time = time.Now() // dig = fib1(num) // end_time = time.Now() // fmt.Printf("%v fib1函数用时: %v\n", dig, end_time.Sub(start_time)) start_time = time.Now() dig = fib2(1, 1, num) end_time = time.Now() fmt.Printf("%v fib2函数用时: %v\n", dig, end_time.Sub(start_time)) start_time = time.Now() m0 := make(map[int]int, 100) dig = fib11(num, m0) end_time = time.Now() fmt.Printf("%v fib11函数用时: %v\n", dig, end_time.Sub(start_time)) start_time = time.Now() s0 := make([]int, num+1, num+1) dig = fib12(num, s0) end_time = time.Now() fmt.Printf("%v fib12函数用时: %v\n", dig, end_time.Sub(start_time)) }
优化后并对比
当num为100000时，明显看出各个函数哪个效率是最高的了。fib12函数和fib11函数的不同之处是采用的缓存方式不同，由于fib12采用的是切片，fib11采用的是hash表，采用切片，省去了hash计算，节省了很多时间。
间接递归
间接递归调用，是函数通过别的函数调用了自己，这一样也是递归。 只要是递归调用，不管是直接还是间接，都需要注意边界返回问题。但是间接递归调用有时候是非常不明显，代码调用复杂时，很难发现出现了递归调用，这是非常危险的。
func foo() { bar() } func bar() { foo() } foo()
递归是一种很自然的表达，符合逻辑思维
递归相对运行效率低，每一次调用函数都要开辟栈帧
递归有深度限制，如果递归层次太深，函数连续压栈，栈内存就可能溢出了
如果是有限次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
绝大多数递归，都可以使用循环实现
函数嵌套
package main import "fmt" func outer() { c := 99 var inner = func() { fmt.Println("1 inner", c, &c) } inner() fmt.Println("2 outer", c, &c) } func main() { outer() }
到outer中定义了另外一个函数inner，并且调用了inner。outer是包级变量，main可见，可以调 用。而inner是outer中的局部变量，outer中可见。
闭包
自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量。
闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JavaScript。闭包是运行期动态的概念。
package main import "fmt" func outer() func() { c := 99 fmt.Printf("outer %d %p\n", c, &c) var inner = func() { fmt.Printf("inner %d %p\n", c, &c) } return inner } func main() { var fn = outer() fn()
首先有嵌套函数，也就是有嵌套作用域，inner函数中用到了c，但是它没有定义c，而外部的outer有局部变量c。
代码分析
defer
defer意思是推迟、延迟。语法很简单，就在正常的语句前加上defer就可以了。
在某函数中使用defer语句，会使得defer后跟的语句进行延迟处理，当该函数即将返回时，或发生 panic时，defer后语句开始执行。
注意os.Exit不是这两种情况，不会执行defer。
同一个函数可以有多个defer语句，依次加入调用栈中（LIFO），函数返回或panic时，从栈顶依次执行 defer后语句。
执行的先后顺序和注册的顺序正好相反，也就是后注册的先执行。 defer后的语句必须是一个函数或方法的调用。
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。