如何克隆包含引用自身的函数字段的Go结构体？

你的问题核心在于：用户设置的printName闭包捕获了原结构体的指针，克隆时直接复制该闭包，导致闭包始终指向原实例，而非新的克隆实例。以下是几种可行的解决方案：

方案1：通过内部自引用字段让闭包动态指向当前实例 #

修改结构体，增加一个self字段指向自身，让用户设置的闭包通过该字段访问结构体成员，而非直接捕获外部指针。克隆时更新self字段指向新实例，这样闭包执行时会访问当前实例的成员。

修改后的代码：

package main

import "fmt"

type MyStruct struct {
    name      string
    printName func()
    self      *MyStruct // 新增自引用字段
}

func NewMyStruct() *MyStruct {
    s := &MyStruct{}
    s.self = s // 初始化时指向自身
    return s
}

func (s *MyStruct) SetName(n string) {
    s.name = n
}

func (s *MyStruct) SetPrint(fn func()) {
    s.printName = fn
}

func (s *MyStruct) Clone() *MyStruct {
    newS := &MyStruct{
        name:  s.name,
        printName: s.printName,
    }
    newS.self = newS // 克隆时更新自引用为新实例
    return newS
}

func main() {
    s := NewMyStruct()
    // 闭包通过self字段访问name，而非直接捕获s
    s.SetPrint(func() {
        fmt.Println(s.self.name)
    })

    s.printName() // 输出 ""

    s.SetName("brother")
    s.printName() // 输出 "brother"

    sClone := s.Clone()
    sClone.printName() // 输出 "brother"

    sClone.SetName("sister")
    sClone.printName() // 输出 "sister"，符合预期
}

方案2：存储闭包生成器而非直接存储闭包 #

如果可以调整内部实现（不破坏对外接口），可以将printName字段改为存储一个闭包生成器，该生成器接收*MyStruct并返回对应的func()。克隆时用新实例重新生成闭包，确保闭包绑定当前实例。

修改后的代码：

package main

import "fmt"

type MyStruct struct {
    name          string
    printNameGen  func(s *MyStruct) func() // 存储生成器
}

func NewMyStruct() *MyStruct {
    return &MyStruct{}
}

func (s *MyStruct) SetName(n string) {
    s.name = n
}

// 对外接口保持不变，兼容原有调用方式
func (s *MyStruct) SetPrint(fn func()) {
    s.printNameGen = func(target *MyStruct) func() {
        return fn
    }
}

// 新增方法让用户直接传入更灵活的生成器（可选）
func (s *MyStruct) SetPrintGenerator(gen func(s *MyStruct) func()) {
    s.printNameGen = gen
}

// 封装printName的调用逻辑，确保使用当前实例
func (s *MyStruct) PrintName() {
    s.printNameGen(s)()
}

func (s *MyStruct) Clone() *MyStruct {
    newS := &MyStruct{
        name:  s.name,
        printNameGen: s.printNameGen,
    }
    return newS
}

func main() {
    s := NewMyStruct()
    // 推荐用户传入生成器形式的逻辑，避免捕获固定指针
    s.SetPrintGenerator(func(target *MyStruct) func() {
        return func() {
            fmt.Println(target.name)
        }
    })

    s.PrintName() // 输出 ""

    s.SetName("brother")
    s.PrintName() // 输出 "brother"

    sClone := s.Clone()
    sClone.PrintName() // 输出 "brother"

    sClone.SetName("sister")
    sClone.PrintName() // 输出 "sister"，符合预期
}

方案说明 #

• 方案1无需修改对外接口，仅需引导用户在设置闭包时通过self字段访问成员，是对现有代码侵入最小的方案。
• 方案2更优雅健壮，通过生成器解耦闭包与实例的绑定关系，但需要调整内部实现，若用户可以配合传入生成器形式的逻辑，更适合长期维护。

内容的提问来源于stack exchange，提问作者Ahmet yazıcı