/*
02-empty-interface.go - Go 语言空接口详解

学习目标：
1. 理解空接口的概念和特性
2. 掌握空接口的使用场景
3. 学会空接口的类型断言
4. 了解空接口的性能考虑
5. 掌握空接口的实际应用

知识点：
- 空接口的定义 interface{}
- 空接口可以持有任何类型的值
- 空接口的类型断言和类型判断
- 空接口在泛型编程中的应用
- 空接口的性能影响
- 空接口的最佳实践
*/

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	fmt.Println("=== Go 语言空接口详解 ===\n")
	
	// 演示空接口的基本概念
	demonstrateBasicEmptyInterface()
	
	// 演示空接口的类型断言
	demonstrateTypeAssertion()
	
	// 演示空接口的类型判断
	demonstrateTypeSwitch()
	
	// 演示空接口的实际应用
	demonstratePracticalUsage()
	
	// 演示空接口的高级用法
	demonstrateAdvancedUsage()
	
	// 演示空接口的性能考虑
	demonstratePerformanceConsiderations()
	
	// 演示空接口的最佳实践
	demonstrateBestPractices()
}

// demonstrateBasicEmptyInterface 演示空接口的基本概念
func demonstrateBasicEmptyInterface() {
	fmt.Println("1. 空接口的基本概念:")
	
	// 空接口的基本特性
	fmt.Printf("   空接口的基本特性:\n")
	fmt.Printf("     - interface{} 不包含任何方法\n")
	fmt.Printf("     - 可以持有任何类型的值\n")
	fmt.Printf("     - 相当于其他语言中的 Object 或 Any\n")
	fmt.Printf("     - 零值是 nil\n")
	fmt.Printf("     - 运行时类型信息保存在接口中\n")
	
	// 基本空接口示例
	fmt.Printf("   基本空接口示例:\n")
	
	var empty interface{}
	fmt.Printf("     空接口零值: %v\n", empty)
	fmt.Printf("     空接口 == nil: %t\n", empty == nil)
	
	// 存储不同类型的值
	empty = 42
	fmt.Printf("     存储整数: %v (类型: %T)\n", empty, empty)
	
	empty = "Hello, World!"
	fmt.Printf("     存储字符串: %v (类型: %T)\n", empty, empty)
	
	empty = 3.14159
	fmt.Printf("     存储浮点数: %v (类型: %T)\n", empty, empty)
	
	empty = true
	fmt.Printf("     存储布尔值: %v (类型: %T)\n", empty, empty)
	
	empty = []int{1, 2, 3, 4, 5}
	fmt.Printf("     存储切片: %v (类型: %T)\n", empty, empty)
	
	empty = map[string]int{"a": 1, "b": 2}
	fmt.Printf("     存储映射: %v (类型: %T)\n", empty, empty)
	
	// 存储结构体
	type Person struct {
		Name string
		Age  int
	}
	
	empty = Person{Name: "Alice", Age: 30}
	fmt.Printf("     存储结构体: %v (类型: %T)\n", empty, empty)
	
	// 存储指针
	person := &Person{Name: "Bob", Age: 25}
	empty = person
	fmt.Printf("     存储指针: %v (类型: %T)\n", empty, empty)
	
	// 存储函数
	empty = func(x int) int { return x * 2 }
	fmt.Printf("     存储函数: %v (类型: %T)\n", empty, empty)
	
	fmt.Println()
}

// demonstrateTypeAssertion 演示空接口的类型断言
func demonstrateTypeAssertion() {
	fmt.Println("2. 空接口的类型断言:")
	
	fmt.Printf("   类型断言用于从接口中提取具体类型的值\n")
	
	// 基本类型断言
	fmt.Printf("   基本类型断言:\n")
	
	var value interface{} = "Hello, Go!"
	
	// 安全的类型断言
	if str, ok := value.(string); ok {
		fmt.Printf("     类型断言成功: %s (长度: %d)\n", str, len(str))
	} else {
		fmt.Printf("     类型断言失败\n")
	}
	
	// 不安全的类型断言（可能 panic）
	str := value.(string)
	fmt.Printf("     直接类型断言: %s\n", str)
	
	// 类型断言失败的情况
	fmt.Printf("   类型断言失败的情况:\n")
	
	value = 42
	if str, ok := value.(string); ok {
		fmt.Printf("     字符串断言成功: %s\n", str)
	} else {
		fmt.Printf("     字符串断言失败，实际类型: %T\n", value)
	}
	
	// 断言为整数
	if num, ok := value.(int); ok {
		fmt.Printf("     整数断言成功: %d\n", num)
	}
	
	// 多种类型断言
	fmt.Printf("   多种类型断言:\n")
	
	values := []interface{}{
		42,
		"Hello",
		3.14,
		true,
		[]int{1, 2, 3},
		map[string]int{"key": 100},
	}
	
	for i, v := range values {
		fmt.Printf("     值 %d (%v):\n", i+1, v)
		
		// 尝试不同的类型断言
		if intVal, ok := v.(int); ok {
			fmt.Printf("       整数: %d\n", intVal)
		} else if strVal, ok := v.(string); ok {
			fmt.Printf("       字符串: %s\n", strVal)
		} else if floatVal, ok := v.(float64); ok {
			fmt.Printf("       浮点数: %.2f\n", floatVal)
		} else if boolVal, ok := v.(bool); ok {
			fmt.Printf("       布尔值: %t\n", boolVal)
		} else {
			fmt.Printf("       其他类型: %T\n", v)
		}
	}
	
	fmt.Println()
}

// demonstrateTypeSwitch 演示空接口的类型判断
func demonstrateTypeSwitch() {
	fmt.Println("3. 空接口的类型判断:")
	
	fmt.Printf("   类型 switch 是处理空接口的优雅方式\n")
	
	// 基本类型 switch
	fmt.Printf("   基本类型 switch:\n")
	
	values := []interface{}{
		42,
		"Hello, World!",
		3.14159,
		true,
		[]int{1, 2, 3, 4, 5},
		map[string]int{"a": 1, "b": 2},
		nil,
		struct{ Name string }{"Alice"},
	}
	
	for i, value := range values {
		fmt.Printf("     值 %d: ", i+1)
		processValue(value)
	}
	
	// 复杂类型 switch
	fmt.Printf("   复杂类型 switch:\n")
	
	complexValues := []interface{}{
		Person{Name: "Alice", Age: 30},
		&Person{Name: "Bob", Age: 25},
		Employee{Person: Person{Name: "Charlie", Age: 35}, Position: "Developer"},
		[]Person{{Name: "David", Age: 28}},
		make(chan int),
		func() { fmt.Println("函数") },
	}
	
	for i, value := range complexValues {
		fmt.Printf("     复杂值 %d: ", i+1)
		processComplexValue(value)
	}
	
	// 类型 switch 的实际应用
	fmt.Printf("   类型 switch 的实际应用:\n")
	
	// JSON 解析模拟
	jsonData := map[string]interface{}{
		"name":    "Alice",
		"age":     30,
		"salary":  75000.50,
		"active":  true,
		"skills":  []interface{}{"Go", "Python", "JavaScript"},
		"address": map[string]interface{}{
			"city":    "New York",
			"zipcode": "10001",
		},
	}
	
	fmt.Printf("     JSON 数据处理:\n")
	processJSONData(jsonData, "")
	
	fmt.Println()
}

// demonstratePracticalUsage 演示空接口的实际应用
func demonstratePracticalUsage() {
	fmt.Println("4. 空接口的实际应用:")
	
	// 应用1: 通用容器
	fmt.Printf("   应用1 - 通用容器:\n")
	
	container := NewContainer()
	
	// 存储不同类型的数据
	container.Add("字符串数据")
	container.Add(42)
	container.Add(3.14)
	container.Add([]int{1, 2, 3})
	
	fmt.Printf("     容器大小: %d\n", container.Size())
	fmt.Printf("     容器内容:\n")
	for i := 0; i < container.Size(); i++ {
		item := container.Get(i)
		fmt.Printf("       [%d]: %v (%T)\n", i, item, item)
	}
	
	// 应用2: 配置系统
	fmt.Printf("   应用2 - 配置系统:\n")
	
	config := NewConfig()
	
	// 设置不同类型的配置
	config.Set("app_name", "MyApp")
	config.Set("port", 8080)
	config.Set("debug", true)
	config.Set("timeout", 30.5)
	config.Set("features", []string{"auth", "logging", "metrics"})
	
	// 获取配置
	fmt.Printf("     应用名称: %v\n", config.Get("app_name"))
	fmt.Printf("     端口: %v\n", config.Get("port"))
	fmt.Printf("     调试模式: %v\n", config.Get("debug"))
	fmt.Printf("     超时时间: %v\n", config.Get("timeout"))
	fmt.Printf("     功能列表: %v\n", config.Get("features"))
	
	// 类型安全的获取
	if port, ok := config.GetInt("port"); ok {
		fmt.Printf("     端口 (类型安全): %d\n", port)
	}
	
	if debug, ok := config.GetBool("debug"); ok {
		fmt.Printf("     调试模式 (类型安全): %t\n", debug)
	}
	
	// 应用3: 事件系统
	fmt.Printf("   应用3 - 事件系统:\n")
	
	eventBus := NewEventBus()
	
	// 注册事件处理器
	eventBus.Subscribe("user_login", func(data interface{}) {
		if user, ok := data.(map[string]interface{}); ok {
			fmt.Printf("       用户登录: %s\n", user["username"])
		}
	})
	
	eventBus.Subscribe("order_created", func(data interface{}) {
		if order, ok := data.(map[string]interface{}); ok {
			fmt.Printf("       订单创建: ID=%v, 金额=$%.2f\n", 
				order["id"], order["amount"])
		}
	})
	
	// 发布事件
	eventBus.Publish("user_login", map[string]interface{}{
		"username": "alice",
		"ip":       "192.168.1.100",
	})
	
	eventBus.Publish("order_created", map[string]interface{}{
		"id":     12345,
		"amount": 99.99,
		"items":  []string{"laptop", "mouse"},
	})
	
	// 应用4: 数据转换
	fmt.Printf("   应用4 - 数据转换:\n")
	
	converter := DataConverter{}
	
	// 转换不同类型的数据
	testData := []interface{}{
		42,
		"123",
		3.14,
		true,
		"false",
		[]int{1, 2, 3},
	}
	
	for _, data := range testData {
		result := converter.ToString(data)
		fmt.Printf("     %v (%T) -> \"%s\"\n", data, data, result)
	}
	
	fmt.Println()
}

// demonstrateAdvancedUsage 演示空接口的高级用法
func demonstrateAdvancedUsage() {
	fmt.Println("5. 空接口的高级用法:")
	
	// 高级用法1: 反射结合空接口
	fmt.Printf("   高级用法1 - 反射结合空接口:\n")
	
	inspector := TypeInspector{}
	
	values := []interface{}{
		42,
		"Hello",
		[]int{1, 2, 3},
		map[string]int{"a": 1},
		Person{Name: "Alice", Age: 30},
		&Person{Name: "Bob", Age: 25},
	}
	
	for _, value := range values {
		inspector.Inspect(value)
	}
	
	// 高级用法2: 深拷贝
	fmt.Printf("   高级用法2 - 深拷贝:\n")
	
	original := map[string]interface{}{
		"name": "Alice",
		"age":  30,
		"address": map[string]interface{}{
			"city": "New York",
			"zip":  "10001",
		},
		"hobbies": []interface{}{"reading", "swimming"},
	}
	
	copied := deepCopy(original)
	
	fmt.Printf("     原始数据: %v\n", original)
	fmt.Printf("     拷贝数据: %v\n", copied)
	
	// 修改拷贝数据
	if copiedMap, ok := copied.(map[string]interface{}); ok {
		copiedMap["name"] = "Bob"
		if address, ok := copiedMap["address"].(map[string]interface{}); ok {
			address["city"] = "Boston"
		}
	}
	
	fmt.Printf("     修改后原始: %v\n", original)
	fmt.Printf("     修改后拷贝: %v\n", copied)
	
	// 高级用法3: 序列化和反序列化
	fmt.Printf("   高级用法3 - 序列化和反序列化:\n")
	
	serializer := SimpleSerializer{}
	
	data := map[string]interface{}{
		"user_id": 123,
		"name":    "Alice",
		"active":  true,
		"score":   95.5,
	}
	
	// 序列化
	serialized := serializer.Serialize(data)
	fmt.Printf("     序列化结果: %s\n", serialized)
	
	// 反序列化
	deserialized := serializer.Deserialize(serialized)
	fmt.Printf("     反序列化结果: %v\n", deserialized)
	
	fmt.Println()
}

// demonstratePerformanceConsiderations 演示空接口的性能考虑
func demonstratePerformanceConsiderations() {
	fmt.Println("6. 空接口的性能考虑:")
	
	fmt.Printf("   空接口的性能影响:\n")
	fmt.Printf("     - 类型信息存储开销\n")
	fmt.Printf("     - 装箱和拆箱成本\n")
	fmt.Printf("     - 类型断言的运行时检查\n")
	fmt.Printf("     - 垃圾回收压力增加\n")
	
	// 性能对比示例
	fmt.Printf("   性能对比示例:\n")
	
	// 直接类型操作
	var directSum int
	for i := 0; i < 1000; i++ {
		directSum += i
	}
	fmt.Printf("     直接类型操作结果: %d\n", directSum)
	
	// 空接口操作
	var interfaceSum int
	var values []interface{}
	for i := 0; i < 1000; i++ {
		values = append(values, i)
	}
	
	for _, v := range values {
		if num, ok := v.(int); ok {
			interfaceSum += num
		}
	}
	fmt.Printf("     空接口操作结果: %d\n", interfaceSum)
	
	// 内存使用对比
	fmt.Printf("   内存使用对比:\n")
	
	// 直接存储
	directSlice := make([]int, 1000)
	for i := range directSlice {
		directSlice[i] = i
	}
	
	// 接口存储
	interfaceSlice := make([]interface{}, 1000)
	for i := range interfaceSlice {
		interfaceSlice[i] = i
	}
	
	fmt.Printf("     直接存储切片长度: %d\n", len(directSlice))
	fmt.Printf("     接口存储切片长度: %d\n", len(interfaceSlice))
	fmt.Printf("     注意: 接口存储会有额外的内存开销\n")
	
	fmt.Println()
}

// demonstrateBestPractices 演示空接口的最佳实践
func demonstrateBestPractices() {
	fmt.Println("7. 空接口的最佳实践:")
	
	fmt.Printf("   最佳实践原则:\n")
	fmt.Printf("     1. 避免过度使用空接口\n")
	fmt.Printf("     2. 优先使用具体类型或定义的接口\n")
	fmt.Printf("     3. 使用类型断言时要检查成功与否\n")
	fmt.Printf("     4. 考虑使用泛型替代空接口（Go 1.18+）\n")
	fmt.Printf("     5. 在 API 边界谨慎使用空接口\n")
	
	// 好的实践示例
	fmt.Printf("   好的实践示例:\n")
	
	// 1. 明确的接口定义
	fmt.Printf("     1. 使用明确的接口而不是空接口:\n")
	
	var printer Printer = ConsolePrinter{}
	printer.Print("使用明确接口的消息")
	
	// 2. 类型安全的容器
	fmt.Printf("     2. 类型安全的容器:\n")
	
	stringContainer := NewTypedContainer[string]()
	stringContainer.Add("Hello")
	stringContainer.Add("World")
	
	fmt.Printf("       字符串容器: %v\n", stringContainer.GetAll())
	
	intContainer := NewTypedContainer[int]()
	intContainer.Add(1)
	intContainer.Add(2)
	intContainer.Add(3)
	
	fmt.Printf("       整数容器: %v\n", intContainer.GetAll())
	
	// 3. 错误处理
	fmt.Printf("     3. 正确的错误处理:\n")
	
	result, err := safeTypeAssertion("Hello, World!", "string")
	if err != nil {
		fmt.Printf("       类型断言错误: %v\n", err)
	} else {
		fmt.Printf("       类型断言成功: %v\n", result)
	}
	
	result, err = safeTypeAssertion(42, "string")
	if err != nil {
		fmt.Printf("       类型断言错误: %v\n", err)
	} else {
		fmt.Printf("       类型断言成功: %v\n", result)
	}
	
	// 避免的反模式
	fmt.Printf("   避免的反模式:\n")
	fmt.Printf("     - 函数参数和返回值过度使用 interface{}\n")
	fmt.Printf("     - 不检查类型断言的成功与否\n")
	fmt.Printf("     - 在性能敏感的代码中大量使用空接口\n")
	fmt.Printf("     - 用空接口替代适当的类型设计\n")
	
	fmt.Println()
}

// ========== 类型定义 ==========

// 基本结构体
type Person struct {
	Name string
	Age  int
}

type Employee struct {
	Person
	Position string
}

// 打印器接口
type Printer interface {
	Print(message string)
}

type ConsolePrinter struct{}

func (cp ConsolePrinter) Print(message string) {
	fmt.Printf("       [控制台] %s\n", message)
}

// ========== 实用工具类型 ==========

// 通用容器
type Container struct {
	items []interface{}
}

func NewContainer() *Container {
	return &Container{items: make([]interface{}, 0)}
}

func (c *Container) Add(item interface{}) {
	c.items = append(c.items, item)
}

func (c *Container) Get(index int) interface{} {
	if index >= 0 && index < len(c.items) {
		return c.items[index]
	}
	return nil
}

func (c *Container) Size() int {
	return len(c.items)
}

// 配置系统
type Config struct {
	data map[string]interface{}
}

func NewConfig() *Config {
	return &Config{data: make(map[string]interface{})}
}

func (c *Config) Set(key string, value interface{}) {
	c.data[key] = value
}

func (c *Config) Get(key string) interface{} {
	return c.data[key]
}

func (c *Config) GetString(key string) (string, bool) {
	if value, exists := c.data[key]; exists {
		if str, ok := value.(string); ok {
			return str, true
		}
	}
	return "", false
}

func (c *Config) GetInt(key string) (int, bool) {
	if value, exists := c.data[key]; exists {
		if num, ok := value.(int); ok {
			return num, true
		}
	}
	return 0, false
}

func (c *Config) GetBool(key string) (bool, bool) {
	if value, exists := c.data[key]; exists {
		if b, ok := value.(bool); ok {
			return b, true
		}
	}
	return false, false
}

// 事件系统
type EventBus struct {
	handlers map[string][]func(interface{})
}

func NewEventBus() *EventBus {
	return &EventBus{handlers: make(map[string][]func(interface{}))}
}

func (eb *EventBus) Subscribe(event string, handler func(interface{})) {
	eb.handlers[event] = append(eb.handlers[event], handler)
}

func (eb *EventBus) Publish(event string, data interface{}) {
	if handlers, exists := eb.handlers[event]; exists {
		for _, handler := range handlers {
			handler(data)
		}
	}
}

// 数据转换器
type DataConverter struct{}

func (dc DataConverter) ToString(value interface{}) string {
	switch v := value.(type) {
	case string:
		return v
	case int:
		return strconv.Itoa(v)
	case float64:
		return strconv.FormatFloat(v, 'f', -1, 64)
	case bool:
		return strconv.FormatBool(v)
	case []int:
		result := "["
		for i, num := range v {
			if i > 0 {
				result += ", "
			}
			result += strconv.Itoa(num)
		}
		result += "]"
		return result
	default:
		return fmt.Sprintf("%v", v)
	}
}

// 类型检查器
type TypeInspector struct{}

func (ti TypeInspector) Inspect(value interface{}) {
	if value == nil {
		fmt.Printf("       nil 值\n")
		return
	}
	
	t := reflect.TypeOf(value)
	v := reflect.ValueOf(value)
	
	fmt.Printf("       类型: %s, 种类: %s, 值: %v\n", t.String(), t.Kind().String(), value)
	
	switch t.Kind() {
	case reflect.Struct:
		fmt.Printf("         结构体字段数: %d\n", t.NumField())
		for i := 0; i < t.NumField(); i++ {
			field := t.Field(i)
			fieldValue := v.Field(i)
			fmt.Printf("           %s: %v (%s)\n", field.Name, fieldValue.Interface(), field.Type)
		}
	case reflect.Ptr:
		fmt.Printf("         指针指向: %s\n", t.Elem().String())
		if !v.IsNil() {
			fmt.Printf("         指针值: %v\n", v.Elem().Interface())
		}
	case reflect.Slice:
		fmt.Printf("         切片长度: %d, 容量: %d\n", v.Len(), v.Cap())
		fmt.Printf("         元素类型: %s\n", t.Elem().String())
	case reflect.Map:
		fmt.Printf("         映射长度: %d\n", v.Len())
		fmt.Printf("         键类型: %s, 值类型: %s\n", t.Key().String(), t.Elem().String())
	}
}

// 简单序列化器
type SimpleSerializer struct{}

func (ss SimpleSerializer) Serialize(data interface{}) string {
	switch v := data.(type) {
	case map[string]interface{}:
		result := "{"
		first := true
		for key, value := range v {
			if !first {
				result += ", "
			}
			result += fmt.Sprintf("\"%s\": %s", key, ss.serializeValue(value))
			first = false
		}
		result += "}"
		return result
	default:
		return ss.serializeValue(data)
	}
}

func (ss SimpleSerializer) serializeValue(value interface{}) string {
	switch v := value.(type) {
	case string:
		return fmt.Sprintf("\"%s\"", v)
	case int:
		return strconv.Itoa(v)
	case float64:
		return strconv.FormatFloat(v, 'f', -1, 64)
	case bool:
		return strconv.FormatBool(v)
	default:
		return fmt.Sprintf("\"%v\"", v)
	}
}

func (ss SimpleSerializer) Deserialize(data string) interface{} {
	// 简化的反序列化，实际应用中应该使用 JSON 包
	if data == "true" {
		return true
	}
	if data == "false" {
		return false
	}
	if num, err := strconv.Atoi(data); err == nil {
		return num
	}
	if num, err := strconv.ParseFloat(data, 64); err == nil {
		return num
	}
	return data
}

// 类型安全的泛型容器（Go 1.18+）
type TypedContainer[T any] struct {
	items []T
}

func NewTypedContainer[T any]() *TypedContainer[T] {
	return &TypedContainer[T]{items: make([]T, 0)}
}

func (tc *TypedContainer[T]) Add(item T) {
	tc.items = append(tc.items, item)
}

func (tc *TypedContainer[T]) Get(index int) T {
	var zero T
	if index >= 0 && index < len(tc.items) {
		return tc.items[index]
	}
	return zero
}

func (tc *TypedContainer[T]) GetAll() []T {
	return tc.items
}

// ========== 辅助函数 ==========

// 处理值的类型 switch
func processValue(value interface{}) {
	switch v := value.(type) {
	case nil:
		fmt.Printf("nil 值\n")
	case int:
		fmt.Printf("整数: %d\n", v)
	case string:
		fmt.Printf("字符串: \"%s\" (长度: %d)\n", v, len(v))
	case float64:
		fmt.Printf("浮点数: %.3f\n", v)
	case bool:
		fmt.Printf("布尔值: %t\n", v)
	case []int:
		fmt.Printf("整数切片: %v (长度: %d)\n", v, len(v))
	case map[string]int:
		fmt.Printf("字符串到整数的映射: %v (大小: %d)\n", v, len(v))
	default:
		fmt.Printf("未知类型: %T, 值: %v\n", v, v)
	}
}

// 处理复杂值的类型 switch
func processComplexValue(value interface{}) {
	switch v := value.(type) {
	case Person:
		fmt.Printf("Person 结构体: %s (%d岁)\n", v.Name, v.Age)
	case *Person:
		fmt.Printf("Person 指针: %s (%d岁)\n", v.Name, v.Age)
	case Employee:
		fmt.Printf("Employee 结构体: %s - %s\n", v.Name, v.Position)
	case []Person:
		fmt.Printf("Person 切片: %d 个人\n", len(v))
	case chan int:
		fmt.Printf("整数通道\n")
	case func():
		fmt.Printf("无参数函数\n")
	default:
		fmt.Printf("其他复杂类型: %T\n", v)
	}
}

// 处理 JSON 数据
func processJSONData(data map[string]interface{}, indent string) {
	for key, value := range data {
		fmt.Printf("%s       %s: ", indent, key)
		
		switch v := value.(type) {
		case string:
			fmt.Printf("\"%s\" (字符串)\n", v)
		case float64:
			fmt.Printf("%.2f (数字)\n", v)
		case bool:
			fmt.Printf("%t (布尔值)\n", v)
		case []interface{}:
			fmt.Printf("数组 [%d 个元素]\n", len(v))
			for i, item := range v {
				fmt.Printf("%s         [%d]: %v (%T)\n", indent, i, item, item)
			}
		case map[string]interface{}:
			fmt.Printf("对象 {%d 个字段}\n", len(v))
			processJSONData(v, indent+"  ")
		default:
			fmt.Printf("%v (%T)\n", v, v)
		}
	}
}

// 深拷贝函数
func deepCopy(original interface{}) interface{} {
	switch v := original.(type) {
	case map[string]interface{}:
		copied := make(map[string]interface{})
		for key, value := range v {
			copied[key] = deepCopy(value)
		}
		return copied
	case []interface{}:
		copied := make([]interface{}, len(v))
		for i, value := range v {
			copied[i] = deepCopy(value)
		}
		return copied
	default:
		// 基本类型直接返回（值拷贝）
		return v
	}
}

// 安全的类型断言
func safeTypeAssertion(value interface{}, expectedType string) (interface{}, error) {
	switch expectedType {
	case "string":
		if str, ok := value.(string); ok {
			return str, nil
		}
		return nil, fmt.Errorf("期望 string 类型，实际是 %T", value)
	case "int":
		if num, ok := value.(int); ok {
			return num, nil
		}
		return nil, fmt.Errorf("期望 int 类型，实际是 %T", value)
	case "bool":
		if b, ok := value.(bool); ok {
			return b, nil
		}
		return nil, fmt.Errorf("期望 bool 类型，实际是 %T", value)
	default:
		return nil, fmt.Errorf("不支持的类型: %s", expectedType)
	}
}

/*
运行这个程序：
go run 02-empty-interface.go

学习要点：
1. 空接口 interface{} 可以持有任何类型的值
2. 空接口是 Go 语言中最通用的类型
3. 使用类型断言从空接口中提取具体类型的值
4. 类型 switch 是处理空接口的优雅方式
5. 空接口在泛型编程和动态类型处理中很有用

空接口的特性：
1. 通用性：可以存储任何类型的值
2. 类型安全：通过类型断言保证类型安全
3. 运行时类型信息：保存值的动态类型信息
4. 零值：空接口的零值是 nil
5. 性能开销：有装箱拆箱的成本

类型断言：
1. 安全断言：value.(Type) 返回值和布尔标志
2. 不安全断言：value.(Type) 只返回值，失败时 panic
3. 类型 switch：switch value.(type) 处理多种类型
4. 类型检查：使用 ok 模式检查断言是否成功

常见应用场景：
1. 通用容器和集合
2. 配置系统和参数传递
3. JSON 和其他格式的数据处理
4. 事件系统和消息传递
5. 插件系统和动态加载
6. 序列化和反序列化
7. 反射和元编程

性能考虑：
1. 装箱开销：基本类型存储到接口需要装箱
2. 类型断言成本：运行时类型检查有开销
3. 内存使用：接口存储需要额外的类型信息
4. 垃圾回收：可能增加 GC 压力

最佳实践：
1. 避免过度使用空接口
2. 优先使用具体类型或定义的接口
3. 使用类型断言时检查成功与否
4. 考虑使用泛型替代空接口（Go 1.18+）
5. 在 API 设计中谨慎使用空接口
6. 提供类型安全的包装函数

何时使用空接口：
1. 需要存储不同类型的值
2. 处理动态类型的数据（如 JSON）
3. 实现通用的算法或容器
4. 与反射结合使用
5. 临时的类型转换需求

何时避免空接口：
1. 类型在编译时已知
2. 性能敏感的代码
3. 可以用泛型替代的场景
4. API 的公共接口设计
5. 简单的数据传递

注意事项：
1. nil 接口不能调用方法
2. 类型断言失败可能导致 panic
3. 空接口比较需要注意动态类型
4. 过度使用会降低代码的类型安全性
5. 调试时类型信息可能不够清晰
*/