/*
04-closures.go - Go 语言闭包详解

学习目标：
1. 理解闭包的概念和原理
2. 掌握闭包的创建和使用
3. 学会闭包的实际应用场景
4. 了解闭包的内存管理
5. 掌握闭包的最佳实践

知识点：
- 闭包的定义和特性
- 词法作用域和变量捕获
- 闭包的生命周期
- 闭包与匿名函数的关系
- 闭包的实际应用模式
- 闭包的性能考虑
*/

package main

import (
	"fmt"
	"math/rand"
	"strings"
	"time"
)

func main() {
	fmt.Println("=== Go 语言闭包详解 ===\n")
	
	// 演示闭包的基本概念
	demonstrateBasicClosures()
	
	// 演示变量捕获
	demonstrateVariableCapture()
	
	// 演示闭包的状态保持
	demonstrateStatefulClosures()
	
	// 演示闭包作为返回值
	demonstrateClosureReturns()
	
	// 演示闭包的实际应用
	demonstratePracticalApplications()
	
	// 演示闭包的高级用法
	demonstrateAdvancedClosureUsage()
	
	// 演示闭包的注意事项
	demonstrateClosureCaveats()
}

// demonstrateBasicClosures 演示闭包的基本概念
func demonstrateBasicClosures() {
	fmt.Println("1. 闭包的基本概念:")
	
	// 基本闭包示例
	fmt.Printf("   基本闭包示例:\n")
	
	// 外部变量
	message := "Hello from closure"
	
	// 创建闭包 - 匿名函数访问外部变量
	closure := func() {
		fmt.Printf("     闭包访问外部变量: %s\n", message)
	}
	
	// 调用闭包
	closure()
	
	// 修改外部变量
	message = "Modified message"
	closure() // 闭包看到修改后的值
	
	// 闭包修改外部变量
	fmt.Printf("   闭包修改外部变量:\n")
	counter := 0
	
	increment := func() {
		counter++
		fmt.Printf("     计数器值: %d\n", counter)
	}
	
	increment()
	increment()
	increment()
	
	fmt.Printf("     外部变量 counter 的最终值: %d\n", counter)
	
	// 多个闭包共享变量
	fmt.Printf("   多个闭包共享变量:\n")
	sharedValue := 10
	
	add := func(n int) {
		sharedValue += n
		fmt.Printf("     add(%d): sharedValue = %d\n", n, sharedValue)
	}
	
	multiply := func(n int) {
		sharedValue *= n
		fmt.Printf("     multiply(%d): sharedValue = %d\n", n, sharedValue)
	}
	
	add(5)      // 10 + 5 = 15
	multiply(2) // 15 * 2 = 30
	add(10)     // 30 + 10 = 40
	
	fmt.Println()
}

// demonstrateVariableCapture 演示变量捕获
func demonstrateVariableCapture() {
	fmt.Println("2. 变量捕获:")
	
	// 值捕获 vs 引用捕获
	fmt.Printf("   值类型变量的捕获:\n")
	
	// 创建多个闭包，每个捕获不同的值
	var functions []func()
	
	for i := 0; i < 3; i++ {
		// 错误的方式：所有闭包都会捕获同一个变量 i
		functions = append(functions, func() {
			fmt.Printf("     错误方式 - i = %d\n", i)
		})
	}
	
	fmt.Printf("   错误的捕获方式（所有闭包都捕获同一个变量）:\n")
	for _, fn := range functions {
		fn() // 都会打印 3，因为循环结束后 i = 3
	}
	
	// 正确的方式：为每个闭包创建独立的变量
	functions = nil
	for i := 0; i < 3; i++ {
		i := i // 创建新的变量，捕获当前值
		functions = append(functions, func() {
			fmt.Printf("     正确方式 - i = %d\n", i)
		})
	}
	
	fmt.Printf("   正确的捕获方式（每个闭包捕获独立的变量）:\n")
	for _, fn := range functions {
		fn()
	}
	
	// 引用类型的捕获
	fmt.Printf("   引用类型变量的捕获:\n")
	slice := []int{1, 2, 3}
	
	modifySlice := func() {
		slice[0] = 999
		fmt.Printf("     闭包修改切片: %v\n", slice)
	}
	
	fmt.Printf("     原始切片: %v\n", slice)
	modifySlice()
	fmt.Printf("     外部切片: %v\n", slice)
	
	fmt.Println()
}

// demonstrateStatefulClosures 演示闭包的状态保持
func demonstrateStatefulClosures() {
	fmt.Println("3. 闭包的状态保持:")
	
	// 计数器闭包
	fmt.Printf("   计数器闭包:\n")
	counter1 := createCounter()
	counter2 := createCounter()
	
	fmt.Printf("     counter1: %d\n", counter1())
	fmt.Printf("     counter1: %d\n", counter1())
	fmt.Printf("     counter2: %d\n", counter2())
	fmt.Printf("     counter1: %d\n", counter1())
	fmt.Printf("     counter2: %d\n", counter2())
	
	// 累加器闭包
	fmt.Printf("   累加器闭包:\n")
	adder := createAdder(10) // 初始值为 10
	
	fmt.Printf("     adder(5): %d\n", adder(5))   // 10 + 5 = 15
	fmt.Printf("     adder(3): %d\n", adder(3))   // 15 + 3 = 18
	fmt.Printf("     adder(-8): %d\n", adder(-8)) // 18 - 8 = 10
	
	// 银行账户闭包
	fmt.Printf("   银行账户闭包:\n")
	account := createBankAccount(1000.0)
	
	fmt.Printf("     初始余额: %.2f\n", account.getBalance())
	fmt.Printf("     存款 500: %.2f\n", account.deposit(500))
	fmt.Printf("     取款 200: %.2f\n", account.withdraw(200))
	fmt.Printf("     取款 2000: %.2f\n", account.withdraw(2000)) // 余额不足
	
	// 历史记录闭包
	fmt.Printf("   历史记录闭包:\n")
	history := createHistory()
	
	history.add("用户登录")
	history.add("查看订单")
	history.add("添加商品到购物车")
	history.add("结算订单")
	
	fmt.Printf("     历史记录:\n")
	for i, record := range history.getAll() {
		fmt.Printf("       %d. %s\n", i+1, record)
	}
	
	fmt.Printf("     最近3条记录:\n")
	for i, record := range history.getLast(3) {
		fmt.Printf("       %d. %s\n", i+1, record)
	}
	
	fmt.Println()
}

// demonstrateClosureReturns 演示闭包作为返回值
func demonstrateClosureReturns() {
	fmt.Println("4. 闭包作为返回值:")
	
	// 数学运算闭包工厂
	fmt.Printf("   数学运算闭包工厂:\n")
	
	add := createMathOperation("add")
	multiply := createMathOperation("multiply")
	power := createMathOperation("power")
	
	fmt.Printf("     add(10, 5) = %.2f\n", add(10, 5))
	fmt.Printf("     multiply(10, 5) = %.2f\n", multiply(10, 5))
	fmt.Printf("     power(2, 8) = %.2f\n", power(2, 8))
	
	// 验证器闭包工厂
	fmt.Printf("   验证器闭包工厂:\n")
	
	emailValidator := createValidator("email")
	phoneValidator := createValidator("phone")
	ageValidator := createValidator("age")
	
	testData := []struct {
		validator func(string) bool
		name      string
		values    []string
	}{
		{emailValidator, "邮箱", []string{"user@example.com", "invalid-email", "test@domain.org"}},
		{phoneValidator, "电话", []string{"138-1234-5678", "123", "186-9999-8888"}},
		{ageValidator, "年龄", []string{"25", "abc", "150", "30"}},
	}
	
	for _, test := range testData {
		fmt.Printf("     %s验证:\n", test.name)
		for _, value := range test.values {
			isValid := test.validator(value)
			fmt.Printf("       \"%s\": %t\n", value, isValid)
		}
	}
	
	// 配置闭包工厂
	fmt.Printf("   配置闭包工厂:\n")
	
	devConfig := createConfigGetter("development")
	prodConfig := createConfigGetter("production")
	
	fmt.Printf("     开发环境数据库: %s\n", devConfig("database"))
	fmt.Printf("     开发环境端口: %s\n", devConfig("port"))
	fmt.Printf("     生产环境数据库: %s\n", prodConfig("database"))
	fmt.Printf("     生产环境端口: %s\n", prodConfig("port"))
	
	fmt.Println()
}

// demonstratePracticalApplications 演示闭包的实际应用
func demonstratePracticalApplications() {
	fmt.Println("5. 闭包的实际应用:")
	
	// 应用1: 事件处理器
	fmt.Printf("   应用1 - 事件处理器:\n")
	
	button := createButton("提交按钮")
	
	// 添加点击事件处理器
	button.onClick(func() {
		fmt.Printf("     按钮被点击了！\n")
	})
	
	// 添加多个事件处理器
	button.onClick(func() {
		fmt.Printf("     记录点击日志\n")
	})
	
	button.onClick(func() {
		fmt.Printf("     发送统计数据\n")
	})
	
	// 触发点击事件
	button.click()
	
	// 应用2: 缓存系统
	fmt.Printf("   应用2 - 缓存系统:\n")
	
	cache := createCache()
	
	// 设置缓存
	cache.set("user:123", "Alice")
	cache.set("user:456", "Bob")
	
	// 获取缓存
	if value, found := cache.get("user:123"); found {
		fmt.Printf("     缓存命中: user:123 = %s\n", value)
	}
	
	if value, found := cache.get("user:789"); found {
		fmt.Printf("     缓存命中: user:789 = %s\n", value)
	} else {
		fmt.Printf("     缓存未命中: user:789\n")
	}
	
	// 显示缓存统计
	stats := cache.getStats()
	fmt.Printf("     缓存统计: 命中 %d 次，未命中 %d 次\n", stats.hits, stats.misses)
	
	// 应用3: 中间件模式
	fmt.Printf("   应用3 - 中间件模式:\n")
	
	// 创建处理器
	handler := func(request string) string {
		return fmt.Sprintf("处理请求: %s", request)
	}
	
	// 应用中间件
	withLogging := loggingMiddleware(handler)
	withAuth := authMiddleware(withLogging)
	withRateLimit := rateLimitMiddleware(withAuth)
	
	// 处理请求
	result := withRateLimit("GET /api/users")
	fmt.Printf("     最终结果: %s\n", result)
	
	// 应用4: 函数式编程
	fmt.Printf("   应用4 - 函数式编程:\n")
	
	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	
	// 使用闭包进行函数式操作
	evenNumbers := filter(numbers, func(n int) bool { return n%2 == 0 })
	fmt.Printf("     偶数: %v\n", evenNumbers)
	
	squares := mapInts(numbers, func(n int) int { return n * n })
	fmt.Printf("     平方: %v\n", squares)
	
	sum := reduce(numbers, 0, func(acc, n int) int { return acc + n })
	fmt.Printf("     求和: %d\n", sum)
	
	// 应用5: 延迟执行
	fmt.Printf("   应用5 - 延迟执行:\n")
	
	// 创建延迟任务
	task1 := createDelayedTask("任务1", func() {
		fmt.Printf("     执行任务1: 发送邮件\n")
	})
	
	task2 := createDelayedTask("任务2", func() {
		fmt.Printf("     执行任务2: 清理缓存\n")
	})
	
	// 延迟执行
	fmt.Printf("     创建延迟任务...\n")
	time.Sleep(100 * time.Millisecond)
	
	task1.execute()
	task2.execute()
	
	fmt.Println()
}

// demonstrateAdvancedClosureUsage 演示闭包的高级用法
func demonstrateAdvancedClosureUsage() {
	fmt.Println("6. 闭包的高级用法:")
	
	// 高级用法1: 柯里化
	fmt.Printf("   高级用法1 - 柯里化:\n")
	
	// 创建柯里化的加法函数
	curriedAdd := curry(func(a, b, c int) int {
		return a + b + c
	})
	
	// 部分应用
	add5 := curriedAdd(5)
	add5And3 := add5(3)
	
	result := add5And3(2) // 5 + 3 + 2 = 10
	fmt.Printf("     柯里化结果: 5 + 3 + 2 = %d\n", result)
	
	// 高级用法2: 记忆化
	fmt.Printf("   高级用法2 - 记忆化:\n")
	
	// 创建记忆化的斐波那契函数
	memoFib := memoize(fibonacci)
	
	fmt.Printf("     计算斐波那契数列:\n")
	for i := 0; i <= 10; i++ {
		result := memoFib(i)
		fmt.Printf("       fib(%d) = %d\n", i, result)
	}
	
	// 高级用法3: 装饰器模式
	fmt.Printf("   高级用法3 - 装饰器模式:\n")
	
	// 原始函数
	slowFunction := func(n int) int {
		time.Sleep(10 * time.Millisecond) // 模拟慢操作
		return n * n
	}
	
	// 应用装饰器
	timedFunction := withTiming(slowFunction)
	cachedFunction := withCaching(timedFunction)
	
	fmt.Printf("     第一次调用:\n")
	result1 := cachedFunction(5)
	fmt.Printf("     结果: %d\n", result1)
	
	fmt.Printf("     第二次调用（应该使用缓存）:\n")
	result2 := cachedFunction(5)
	fmt.Printf("     结果: %d\n", result2)
	
	// 高级用法4: 状态机
	fmt.Printf("   高级用法4 - 状态机:\n")
	
	fsm := createStateMachine()
	
	fmt.Printf("     当前状态: %s\n", fsm.getState())
	fsm.start()
	fmt.Printf("     当前状态: %s\n", fsm.getState())
	fsm.pause()
	fmt.Printf("     当前状态: %s\n", fsm.getState())
	fsm.resume()
	fmt.Printf("     当前状态: %s\n", fsm.getState())
	fsm.stop()
	fmt.Printf("     当前状态: %s\n", fsm.getState())
	
	// 高级用法5: 观察者模式
	fmt.Printf("   高级用法5 - 观察者模式:\n")
	
	subject := createSubject()
	
	// 添加观察者
	subject.subscribe(func(data interface{}) {
		fmt.Printf("     观察者1收到数据: %v\n", data)
	})
	
	subject.subscribe(func(data interface{}) {
		fmt.Printf("     观察者2收到数据: %v\n", data)
	})
	
	// 通知观察者
	subject.notify("Hello, Observers!")
	subject.notify(42)
	
	fmt.Println()
}

// demonstrateClosureCaveats 演示闭包的注意事项
func demonstrateClosureCaveats() {
	fmt.Println("7. 闭包的注意事项:")
	
	// 注意事项1: 循环变量捕获
	fmt.Printf("   注意事项1 - 循环变量捕获:\n")
	fmt.Printf("     这是一个常见的陷阱，前面已经演示过\n")
	
	// 注意事项2: 内存泄漏
	fmt.Printf("   注意事项2 - 内存泄漏风险:\n")
	fmt.Printf("     闭包会保持对外部变量的引用，可能导致内存泄漏\n")
	
	// 创建一个可能导致内存泄漏的示例
	largeData := make([]int, 1000000) // 大数组
	for i := range largeData {
		largeData[i] = i
	}
	
	// 闭包只使用数组的第一个元素，但会保持整个数组的引用
	getClosure := func() func() int {
		return func() int {
			return largeData[0] // 只使用第一个元素
		}
	}
	
	closure := getClosure()
	fmt.Printf("     闭包结果: %d\n", closure())
	fmt.Printf("     注意: 闭包保持了整个大数组的引用\n")
	
	// 更好的做法：只捕获需要的数据
	getBetterClosure := func() func() int {
		firstElement := largeData[0] // 只捕获需要的值
		return func() int {
			return firstElement
		}
	}
	
	betterClosure := getBetterClosure()
	fmt.Printf("     改进的闭包结果: %d\n", betterClosure())
	fmt.Printf("     改进: 只捕获需要的值，不保持大数组引用\n")
	
	// 注意事项3: 性能考虑
	fmt.Printf("   注意事项3 - 性能考虑:\n")
	fmt.Printf("     闭包的创建和调用有一定的性能开销\n")
	
	// 测量闭包 vs 普通函数的性能
	normalFunc := func(x int) int { return x * 2 }
	
	multiplier := 2
	closureFunc := func(x int) int { return x * multiplier }
	
	// 简单的性能比较（实际测试需要更严格的基准测试）
	start := time.Now()
	for i := 0; i < 1000000; i++ {
		normalFunc(i)
	}
	normalTime := time.Since(start)
	
	start = time.Now()
	for i := 0; i < 1000000; i++ {
		closureFunc(i)
	}
	closureTime := time.Since(start)
	
	fmt.Printf("     普通函数耗时: %v\n", normalTime)
	fmt.Printf("     闭包函数耗时: %v\n", closureTime)
	
	// 最佳实践
	fmt.Printf("   最佳实践:\n")
	fmt.Printf("     1. 避免在循环中直接使用循环变量创建闭包\n")
	fmt.Printf("     2. 只捕获必要的变量，避免捕获大对象\n")
	fmt.Printf("     3. 注意闭包的生命周期，避免内存泄漏\n")
	fmt.Printf("     4. 在性能敏感的代码中谨慎使用闭包\n")
	fmt.Printf("     5. 使用闭包实现优雅的设计模式\n")
	
	fmt.Println()
}

// ========== 函数定义 ==========

// 基本闭包函数
func createCounter() func() int {
	count := 0
	return func() int {
		count++
		return count
	}
}

func createAdder(initial int) func(int) int {
	sum := initial
	return func(n int) int {
		sum += n
		return sum
	}
}

// 银行账户闭包
type BankAccount struct {
	getBalance func() float64
	deposit    func(float64) float64
	withdraw   func(float64) float64
}

func createBankAccount(initialBalance float64) BankAccount {
	balance := initialBalance
	
	return BankAccount{
		getBalance: func() float64 {
			return balance
		},
		deposit: func(amount float64) float64 {
			if amount > 0 {
				balance += amount
			}
			return balance
		},
		withdraw: func(amount float64) float64 {
			if amount > 0 && amount <= balance {
				balance -= amount
			}
			return balance
		},
	}
}

// 历史记录闭包
type History struct {
	add     func(string)
	getAll  func() []string
	getLast func(int) []string
}

func createHistory() History {
	var records []string
	
	return History{
		add: func(record string) {
			records = append(records, record)
		},
		getAll: func() []string {
			result := make([]string, len(records))
			copy(result, records)
			return result
		},
		getLast: func(n int) []string {
			if n >= len(records) {
				result := make([]string, len(records))
				copy(result, records)
				return result
			}
			result := make([]string, n)
			copy(result, records[len(records)-n:])
			return result
		},
	}
}

// 数学运算闭包工厂
func createMathOperation(operation string) func(float64, float64) float64 {
	switch operation {
	case "add":
		return func(a, b float64) float64 { return a + b }
	case "subtract":
		return func(a, b float64) float64 { return a - b }
	case "multiply":
		return func(a, b float64) float64 { return a * b }
	case "divide":
		return func(a, b float64) float64 {
			if b != 0 {
				return a / b
			}
			return 0
		}
	case "power":
		return func(a, b float64) float64 {
			result := 1.0
			for i := 0; i < int(b); i++ {
				result *= a
			}
			return result
		}
	default:
		return func(a, b float64) float64 { return 0 }
	}
}

// 验证器闭包工厂
func createValidator(validationType string) func(string) bool {
	switch validationType {
	case "email":
		return func(email string) bool {
			return len(email) > 0 && 
				   strings.Contains(email, "@") && 
				   strings.Contains(email, ".")
		}
	case "phone":
		return func(phone string) bool {
			return len(phone) >= 10 && strings.Contains(phone, "-")
		}
	case "age":
		return func(ageStr string) bool {
			// 简单验证：只检查是否为数字
			for _, char := range ageStr {
				if char < '0' || char > '9' {
					return false
				}
			}
			return len(ageStr) > 0
		}
	default:
		return func(string) bool { return false }
	}
}

// 配置闭包工厂
func createConfigGetter(environment string) func(string) string {
	configs := map[string]map[string]string{
		"development": {
			"database": "localhost:5432",
			"port":     "8080",
			"debug":    "true",
		},
		"production": {
			"database": "prod-db:5432",
			"port":     "80",
			"debug":    "false",
		},
	}
	
	envConfig := configs[environment]
	
	return func(key string) string {
		if value, exists := envConfig[key]; exists {
			return value
		}
		return ""
	}
}

// 事件处理器
type Button struct {
	name     string
	handlers []func()
}

func createButton(name string) *Button {
	return &Button{name: name}
}

func (b *Button) onClick(handler func()) {
	b.handlers = append(b.handlers, handler)
}

func (b *Button) click() {
	fmt.Printf("     点击按钮: %s\n", b.name)
	for _, handler := range b.handlers {
		handler()
	}
}

// 缓存系统
type Cache struct {
	set      func(string, string)
	get      func(string) (string, bool)
	getStats func() struct{ hits, misses int }
}

func createCache() Cache {
	data := make(map[string]string)
	hits := 0
	misses := 0
	
	return Cache{
		set: func(key, value string) {
			data[key] = value
		},
		get: func(key string) (string, bool) {
			if value, exists := data[key]; exists {
				hits++
				return value, true
			}
			misses++
			return "", false
		},
		getStats: func() struct{ hits, misses int } {
			return struct{ hits, misses int }{hits, misses}
		},
	}
}

// 中间件模式
func loggingMiddleware(next func(string) string) func(string) string {
	return func(request string) string {
		fmt.Printf("     [LOG] 处理请求: %s\n", request)
		result := next(request)
		fmt.Printf("     [LOG] 请求完成: %s\n", request)
		return result
	}
}

func authMiddleware(next func(string) string) func(string) string {
	return func(request string) string {
		fmt.Printf("     [AUTH] 验证请求: %s\n", request)
		// 模拟认证
		if strings.Contains(request, "GET") {
			return next(request)
		}
		return "认证失败"
	}
}

func rateLimitMiddleware(next func(string) string) func(string) string {
	requestCount := 0
	return func(request string) string {
		requestCount++
		fmt.Printf("     [RATE] 请求计数: %d\n", requestCount)
		if requestCount > 10 {
			return "请求过于频繁"
		}
		return next(request)
	}
}

// 函数式编程辅助函数
func filter(slice []int, predicate func(int) bool) []int {
	var result []int
	for _, item := range slice {
		if predicate(item) {
			result = append(result, item)
		}
	}
	return result
}

func mapInts(slice []int, mapper func(int) int) []int {
	result := make([]int, len(slice))
	for i, item := range slice {
		result[i] = mapper(item)
	}
	return result
}

func reduce(slice []int, initial int, reducer func(int, int) int) int {
	result := initial
	for _, item := range slice {
		result = reducer(result, item)
	}
	return result
}

// 延迟执行
type DelayedTask struct {
	name    string
	task    func()
	execute func()
}

func createDelayedTask(name string, task func()) DelayedTask {
	return DelayedTask{
		name: name,
		task: task,
		execute: func() {
			fmt.Printf("     准备执行延迟任务: %s\n", name)
			task()
		},
	}
}

// 柯里化
func curry(fn func(int, int, int) int) func(int) func(int) func(int) int {
	return func(a int) func(int) func(int) int {
		return func(b int) func(int) int {
			return func(c int) int {
				return fn(a, b, c)
			}
		}
	}
}

// 记忆化
func memoize(fn func(int) int) func(int) int {
	cache := make(map[int]int)
	return func(n int) int {
		if result, exists := cache[n]; exists {
			return result
		}
		result := fn(n)
		cache[n] = result
		return result
	}
}

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

// 装饰器模式
func withTiming(fn func(int) int) func(int) int {
	return func(n int) int {
		start := time.Now()
		result := fn(n)
		duration := time.Since(start)
		fmt.Printf("       函数执行耗时: %v\n", duration)
		return result
	}
}

func withCaching(fn func(int) int) func(int) int {
	cache := make(map[int]int)
	return func(n int) int {
		if result, exists := cache[n]; exists {
			fmt.Printf("       使用缓存结果\n")
			return result
		}
		fmt.Printf("       计算新结果\n")
		result := fn(n)
		cache[n] = result
		return result
	}
}

// 状态机
type StateMachine struct {
	getState func() string
	start    func()
	pause    func()
	resume   func()
	stop     func()
}

func createStateMachine() StateMachine {
	state := "idle"
	
	return StateMachine{
		getState: func() string {
			return state
		},
		start: func() {
			if state == "idle" {
				state = "running"
			}
		},
		pause: func() {
			if state == "running" {
				state = "paused"
			}
		},
		resume: func() {
			if state == "paused" {
				state = "running"
			}
		},
		stop: func() {
			if state == "running" || state == "paused" {
				state = "idle"
			}
		},
	}
}

// 观察者模式
type Subject struct {
	subscribe func(func(interface{}))
	notify    func(interface{})
}

func createSubject() Subject {
	var observers []func(interface{})
	
	return Subject{
		subscribe: func(observer func(interface{})) {
			observers = append(observers, observer)
		},
		notify: func(data interface{}) {
			for _, observer := range observers {
				observer(data)
			}
		},
	}
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

/*
运行这个程序：
go run 04-closures.go

学习要点：
1. 闭包是函数和其词法环境的组合
2. 闭包可以访问和修改外部作用域的变量
3. 闭包可以保持状态，实现数据封装
4. 闭包常用于回调函数、事件处理、函数式编程
5. 需要注意循环变量捕获和内存泄漏问题

闭包的特性：
1. 词法作用域：闭包可以访问定义时的作用域
2. 变量捕获：闭包会捕获外部变量的引用
3. 状态保持：闭包可以在多次调用间保持状态
4. 延迟执行：闭包可以延迟执行代码

常见应用场景：
1. 事件处理和回调函数
2. 函数式编程（map、filter、reduce）
3. 中间件和装饰器模式
4. 状态管理和数据封装
5. 配置和选项处理
6. 缓存和记忆化
7. 延迟执行和任务调度

设计模式：
1. 工厂模式：返回配置好的闭包
2. 装饰器模式：包装函数添加功能
3. 观察者模式：事件处理和通知
4. 状态机模式：状态管理
5. 策略模式：动态选择算法

最佳实践：
1. 避免在循环中直接捕获循环变量
2. 只捕获必要的变量，避免内存泄漏
3. 合理使用闭包实现优雅的API设计
4. 注意闭包的性能开销
5. 使用闭包实现函数式编程风格

注意事项：
1. 循环变量捕获陷阱
2. 内存泄漏风险
3. 性能开销
4. 调试困难
5. 代码可读性

高级用法：
1. 柯里化和部分应用
2. 记忆化优化
3. 函数组合和管道
4. 异步编程模式
5. 依赖注入
*/