【无标题】

闭包的记忆效应
被捕获到闭包中的变量让闭包本身拥有了记忆效应，闭包中的逻辑可以修改闭包捕获的变量，变量会跟随闭包生命期一直存在，闭包本身就如同变量一样拥有了记忆效应。

package main
import (
“fmt”
)

func Accumulate(value int) func() int {
// 返回一个闭包
return func() int {
// 累加
value++
// 返回一个累加值
return value
}
}
func main() {
// 创建一个累加器, 初始值为1
accumulator := Accumulate(1)
// 累加1并打印
fmt.Println(accumulator())
fmt.Println(accumulator())
// 打印累加器的函数地址
fmt.Printf(“%p\n”, &accumulator)
// 创建一个累加器, 初始值为1
accumulator2 := Accumulate(10)
// 累加1并打印
fmt.Println(accumulator2())
// 打印累加器的函数地址
fmt.Printf(“%p\n”, &accumulator2)
}

我们看下，使用闭包函数实现计数器。
package main
mport “fmt”
func main() {
pos := adder()
for i := 0; i < 10; i++ {
fmt.Printf(“i=%d \t”, i)
fmt.Println(pos(i))
}
fmt.Println(“--------------------”)
for i := 0; i < 10; i++ {
fmt.Printf(“i=%d \t”, i)
fmt.Println(pos(i))
}
}
func adder() func(int) int {
sum := 0
return func(x int) int
fmt.Printf(“sum1=%d \t”, sum)
sum += x
fmt.Printf(“sum2=%d \t”, sum)
return sum
}
}

// 通过高阶函数在不侵入原有函数实现的前提下计算乘法函数执行时间
func execTime(f MultiPlyFunc) MultiPlyFunc {
return func(a, b int) int {
start := time.Now() // 起始时间
c := f(a, b) // 执行乘法运算函数
end := time.Since(start) // 函数执行完毕耗时
fmt.Printf(“— 执行耗时: %v —\n”, end)
return c // 返回计算结果
}
}
func main() {
a := 2
b := 8
// 通过修饰器调用乘法函数，返回的是一个匿名函数
decorator := execTime(multiply)
// 执行修饰器返回函数
c := decorator(a, b)
fmt.Printf(“%d x %d = %d\n”, a, b, c)
}

计算n的乘阶
func recursive(n int)int{

if(n==1){
	return 1
}else{
	return recursive(n-1)+n*n
}

}

func main(){
fmt.Printf(“%d”,recursive(3))
}

输出结果是14
计算斐波那契数列
普通方法的实现思路是，要计算数列中第 n 个数字，需要先得到它前面的两个数，以此类推。这么做的弊端是会产生大量的重复计算，代码如下所示：
package main
import (
“fmt”
“time”
)
func main() {
result := 0
start := time.Now()
for i := 1; i <= 40; i++ {
result = fibonacci(i)
fmt.Printf(“数列第 %d 位: %d\n”, i, result)
}
end := time.Now()
delta := end.Sub(start)
fmt.Printf(“程序的执行时间为: %s\n”, delta)
}
func fibonacci(n int) (res int) {
if n <= 2 {
res = 1
} else {
res = fibonacci(n-1) + fibonacci(n-2)
}
return
}