Object Go：方法切片和结构中的方法

是否可以创建一个方法片段或指向方法的指针片段，并将它们存储在结构中的字段中

以下是该问题的一个示例：

package main

import (
  "fmt"
)

type Foo struct {
  fooFunc func() /// Problem here
  name string
  age int
}

type Bar struct {
  barFunc []func() /// Problem here.
  salary int
  debt int
}

func main() {

  fooObject := Foo{name: "micheal",
             fooFunc: testFunc}

  fooObject.fooFunc() 

  fooObject = Foo{name: "lisa",
          age : 22,
          fooFunc: testFunc2}

  fooObject.fooFunc() 


  barFuncList := make([]func(), 2,2)
  barFuncList[0] = barSalary
  barFuncList[1] = barDebt

  barObject := Bar{name: fooObject.name,
           salary: 45000,
           debt: 200,
           barFunc: barFuncList)

  for i := 0; i < len(barObject.barFunc); i++{  // This is what I really want to do
    barObject.barFunc[i]
  }
}

func (bar *Foo) testfunc() {
  fmt.Println(bar.name)
}

func (bar *Foo) testfunc2() {
  fmt.Println("My name is ", bar.name , " and my age is " , bar.age)
}

func (foo *Bar) barSalary() {
  fmt.Println(" My salary is " , foo.salary)
}

func (foo *Bar) barDebt() {
  fmt.Println(" My salary is " , foo.debt)
}

主程序包
进口(
“fmt”
)
类型Foo struct{
fooFunc func（）///这里有问题
名称字符串
年龄智力
}
类型栏结构{
barFunc[]func（）///这里有问题。
工资整数
债务整数
}
func main（）{
fooObject:=Foo{name:“micheal”，
fooFunc:testFunc}
fooObject.fooFunc（）
fooObject=Foo{name:“lisa”，
年龄:22,，
fooFunc:testFunc2}
fooObject.fooFunc（）
barFuncList:=make（[]func（），2,2）
barFuncList[0]=barSalary
barFuncList[1]=barDebt
barObject:=Bar{name:fooObject.name，
工资：45000，
债务：200，
barFunc:barFuncList）
对于i:=0；i

有没有办法将对象的方法附加到其结构的字段

---

也可以将对象方法的一部分放在其结构的字段中吗？

我认为您不能动态更新结构字段中的方法，但可以动态调度方法。

Go无法进行猴子修补（万岁！），但如果您真的愿意，您可以从对象方法执行动态函数调用

主程序包
进口(
“fmt”
)
类型FF func（*Foo）
类型Foo struct{
富芬奇酒店
名称字符串
年龄智力
}
func Foo 1（f*Foo）{
fmt.Println（“[foo1]”，f.name）
}
func Foo 2（f*Foo）{
fmt.Println（“[foo2]我的名字是”，f.name，“我的年龄是”，f.age）
}
类型BB func（*Bar）
类型栏结构{
barFuncs[]BB
工资整数
债务整数
}
func barSalary（b*Bar）{
fmt.Println（“[barSalary]我的薪水是”，b.salary）
}
func barDebt（b*Bar）{
fmt.Println（“[barDebt]我的薪水是”，b.债务）
}
func main（）{
fooObject:=Foo{
姓名：“micheal”，
}
fooObject.foofunc=foo1
fooObject.foofunc（&fooObject）
fooObject=Foo{
姓名：“丽莎”，
年龄:22,，
}
fooObject.foofunc=foo2
fooObject.foofunc（&fooObject）
barFuncList:=make（[]BB，2，2）
barFuncList[0]=barSalary
barFuncList[1]=barDebt
barObject:=巴{
工资：45000，
债务：200，
barFuncs:barFuncList，
}
对于i:=0；i

“通过网络动态更新与这些对象关联的方法”在上帝的绿色地球上，谁会想要维护代码？如果你想要动态对象，请使用动态语言。在这种情况下，维护不是问题。这个问题与类似，只是指针的数组/切片应该是结构的一个字段。我不认为OP解决了他的问题（他没有很好地解释）以惯用的方式；尽管如此，这里有一个更接近OPs原始代码的语法修正（比上面的更接近）：@voidlogic抱歉，但当时我不知道如何更好地描述它，所以我键入了一些示例代码来显示我正在尝试做的事情。您的版本正是我一直在尝试做的。谢谢。

package main

import (
  "fmt"
)

type FF func(*Foo)

type Foo struct {
  foofunc FF
  name string
  age int
}

func foo1(f *Foo) {
        fmt.Println("[foo1]", f.name)
}

func foo2(f *Foo) {
        fmt.Println("[foo2] My name is ", f.name , " and my age is " , f.age)
}


type BB func(*Bar)

type Bar struct {
  barFuncs []BB
  salary int
  debt int
}

func barSalary(b *Bar) {
        fmt.Println("[barSalary] My salary is " , b.salary)
}

func barDebt(b *Bar) {
        fmt.Println("[barDebt] My salary is ", b.debt)
}

func main() {

        fooObject := Foo{
                name: "micheal",
        }
        fooObject.foofunc = foo1

        fooObject.foofunc(&fooObject)

        fooObject = Foo{
                name: "lisa",
                age : 22,
        }
        fooObject.foofunc = foo2

        fooObject.foofunc(&fooObject)



        barFuncList := make([]BB, 2, 2)
        barFuncList[0] = barSalary
        barFuncList[1] = barDebt

        barObject := Bar{
                salary: 45000,
                debt: 200,
                barFuncs: barFuncList,
        }

        for i := 0; i < len(barObject.barFuncs); i++ {
                barObject.barFuncs[i](&barObject)
        }
}