常见问题和错误

// 错误示例
func leakyGoroutine() {
    ch := make(chan int)
    go func() {
        // 这个goroutine可能永远阻塞
        ch <- 42
    }()
    // 没有接收通道数据，goroutine泄漏
}

// 正确示例
func nonLeakyGoroutine() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    // 确保接收数据
    <-ch
}

// 使用context控制goroutine生命周期
func contextControlledGoroutine(ctx context.Context) {
    ch := make(chan int)
    go func() {
        select {
        case ch <- 42:
        case <-ctx.Done():
            return
        }
    }()
    select {
    case <-ch:
    case <-ctx.Done():
        return
    }
}

// 错误示例
func deadlock() {
    ch := make(chan int)
    ch <- 1  // 死锁：无缓冲通道的发送操作会阻塞
    <-ch
}

// 正确示例
func nonDeadlock() {
    ch := make(chan int, 1)  // 使用缓冲通道
    ch <- 1
    <-ch

    // 或者使用goroutine
    ch2 := make(chan int)
    go func() {
        ch2 <- 1
    }()
    <-ch2
}

// 错误示例
type Person struct {
    Name string
}

func (p *Person) GetName() string {
    return p.Name  // 如果p为nil，将导致panic
}

// 正确示例
func (p *Person) GetName() string {
    if p == nil {
        return ""
    }
    return p.Name
}

// 错误示例
func isNil(i interface{}) bool {
    return i == nil  // 可能出现误判
}

// 正确示例
func isNil(i interface{}) bool {
    return i == nil || reflect.ValueOf(i).IsNil()
}

// 错误示例
func appendSlice() {
    s := make([]int, 0)
    for i := 0; i < 1000; i++ {
        s = append(s, i)  // 频繁扩容，性能差
    }
}

// 正确示例
func appendSliceOptimized() {
    s := make([]int, 0, 1000)  // 预分配容量
    for i := 0; i < 1000; i++ {
        s = append(s, i)
    }
}

// 可能导致问题的示例
func sliceShare() {
    original := []int{1, 2, 3, 4, 5}
    slice1 := original[1:3]
    slice1[0] = 20  // 会修改original中的元素

    // 如果不想共享，应该使用copy
    slice2 := make([]int, len(original))
    copy(slice2, original)
}

# Python中的变量作用域
def counter():
    count = 0
    def increment():
        count += 1  # 在Python中可以使用nonlocal
        return count
    return increment

// Go中的变量作用域
func counter() func() int {
    count := 0
    return func() int {
        count++  // Go中闭包可以直接访问外部变量
        return count
    }
}

// Java中的继承和多态
class Animal {
    public void makeSound() {}
}
class Dog extends Animal {
    @Override
    public void makeSound() {}
}

// Go中使用接口和组合
type Animal interface {
    MakeSound()
}

type Dog struct{}

func (d Dog) MakeSound() {}

// C#中的属性
public class Person {
    private string name;
    public string Name {
        get { return name; }
        set { name = value; }
    }
}

// Go中的getter/setter
type Person struct {
    name string
}

func (p *Person) Name() string {
    return p.name
}

func (p *Person) SetName(name string) {
    p.name = name
}