1 什么是闭包

闭包是指一个函数（或函数值）与其引用的外部变量（自由变量）的绑定关系。换句话说，闭包是一个函数和其相关的引用环境的组合体。

在闭包中，内部函数可以访问外部函数的变量，即使外部函数已经执行完毕，内部函数仍然可以使用外部函数的变量。这是因为闭包会在创建时将外部变量的引用保存在自己的环境中，所以即使外部函数退出后，这些变量仍然可以被内部函数访问和操作。

2 闭包的使用场景有哪些

在Go语言中，闭包具有很多有用的应用场景，包括但不限于：

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("Deferred execution")
	}()

	fmt.Println("Main function")
}

package main

import "fmt"

func memoize(f func(int) int) func(int) int {
	cache := make(map[int]int)
	return func(n int) int {
		if result, ok := cache[n]; ok {
			return result
		}
		result := f(n)
		cache[n] = result
		return result
	}
}

func fibonacci(n int) int {
	if n <= 1 {
		return n
	}
	return fibonacci(n-1) + fibonacci(n-2)
}

func main() {
	fib := memoize(fibonacci)
	fmt.Println(fib(10))
	fmt.Println(fib(5))
}

package main

import "fmt"

func makeGreeter(name string) func() {
	return func() {
		fmt.Printf("Hello, %s!\n", name)
	}
}

func main() {
	greeter := makeGreeter("John")
	greeter()
}

package main

import "fmt"

type Button struct {
	onClick func()
}

func (b *Button) Click() {
	if b.onClick != nil {
		b.onClick()
	}
}

func main() {
	button := &Button{
		onClick: func() {
			fmt.Println("Button clicked!")
		},
	}

	button.Click()
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	var counter int
	var wg sync.WaitGroup
	var mu sync.Mutex

	increment := func() {
		mu.Lock()
		counter++
		mu.Unlock()
		wg.Done()
	}

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go increment()
	}

	wg.Wait()
	fmt.Println("Counter:", counter)
}

这些只是闭包的一些常见应用场景，实际上闭包在编程中非常灵活，可以根据具体的需求进行创造性的应用。通过使用闭包，可以更好地组织和管理代码，实现更灵活、可复用和可扩展的功能。

3 闭包会触发逃逸分析吗

什么是逃逸分析：
逃逸分析是Go编译器的一个优化技术，用于确定一个局部变量是否逃逸到了堆上分配内存。如果一个变量逃逸到了堆上，意味着它在函数执行完后仍然可以被访问，编译器会将其分配在堆上，以保证其生命周期。

是的，闭包在Go语言中会触发逃逸分析。
闭包中的函数常常会引用外部的变量，这些变量可能是局部变量或函数的参数。如果闭包中的函数将这些外部变量持久化（返回函数、存储到全局变量等），那么这些变量就逃逸到了堆上，因为它们在函数执行完后仍然可以被访问。逃逸分析会判断这些变量是否逃逸，并根据情况将其分配在堆上。

逃逸分析的结果会对代码的性能和内存分配产生影响。如果闭包中的变量逃逸到了堆上，可能会导致额外的内存分配和垃圾回收的开销。因此，在设计闭包时，需要注意避免不必要的变量逃逸，尽量减少对堆的依赖，以提高代码的性能和效率。