本文探讨了在go语言结构体中存储函数和函数切片的方法，以实现灵活的动态行为。通过定义特定的函数类型，并将其作为结构体字段，我们可以将接收者作为参数的函数赋值给这些字段，进而动态调用。这为实现策略模式或命令模式等设计提供了有效途径，同时保持了go的类型安全和编译时检查。
引言
在Go语言的开发实践中，我们经常会遇到需要为结构体实例赋予动态行为的场景。这意味着在程序运行时，根据不同的条件或状态，结构体实例能够执行不同的操作。一种实现此目标的需求是，将一个或一组函数直接存储在结构体的字段中，并在需要时进行调用。尽管Go语言不提供“猴子补丁”这类运行时修改类型方法的机制，但它通过类型安全的方式，允许我们在结构体中嵌入函数类型字段，从而优雅地实现动态行为。
本文将深入探讨如何在Go结构体中定义和利用函数类型字段，包括存储单个函数和函数切片，以此来构建更具灵活性和可配置性的应用程序。
定义函数类型
实现结构体动态行为的核心在于定义一个函数类型，其签名必须与我们将要存储的函数相匹配。这些函数虽然在语法上是独立的函数，而非Go语言传统意义上的“方法”（即带有接收者的方法），但它们通过接收一个指向特定结构体实例的指针作为参数，可以有效地访问和操作该实例的数据，从而模拟出方法的行为。
例如，如果我们有一个 Foo 结构体，可以定义一个名为 FF 的函数类型，它接受一个 *Foo 类型的参数：
立即学习“go语言免费学习笔记（深入）”；
// FF 是一个函数类型，它接受一个 *Foo 类型的参数，无返回值
type FF func(*Foo)
// Foo结构体定义，包含一个FF类型的函数字段
type Foo struct {
foofunc FF // 存储一个FF类型的函数
name string
age int
}同理，对于 Bar 结构体，我们可以定义一个 BB 类型来处理其相关操作：
// BB 是一个函数类型，它接受一个 *Bar 类型的参数，无返回值
type BB func(*Bar)
// Bar结构体定义，包含一个BB类型的函数切片字段
type Bar struct {
barFuncs []BB // 存储一个BB类型的函数切片
salary int
debt int
}通过这种方式，我们为将要存储的函数定义了一个清晰且类型安全的接口。任何符合 FF 或 BB 签名的函数都可以被赋值给相应的字段。
在结构体中嵌入单个函数
定义好函数类型后，我们就可以将其作为结构体的一个字段。这样，在创建结构体实例时或之后的任何时间点，都可以将符合该函数签名的具体函数赋值给这个字段。
以下是一个关于 Foo 结构体如何嵌入并调用单个函数的示例：
package main
import "fmt"
// 定义Foo结构体的函数类型
type FF func(*Foo)
// Foo结构体定义
type Foo struct {
foofunc FF
name string
age int
}
// 两个符合FF签名的普通函数，用于操作Foo实例
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)
}
func main() {
// 实例化Foo，并为其foofunc字段赋值foo1函数
fooObject := Foo{
name: "micheal",
}
fooObject.foofunc = foo1 // 将foo1函数赋值给foofunc字段
// 调用存储的函数，并显式传入结构体实例的指针
fooObject.foofunc(&fooObject)
// 重新实例化Foo，并为其foofunc字段赋值foo2函数
fooObject = Foo{
name: "lisa",
age: 22,
}
fooObject.foofunc = foo2 // 将foo2函数赋值给foofunc字段
// 再次调用
fooObject.foofunc(&fooObject)
}在上述代码中，foo1 和 foo2 是普通的函数，它们都接受一个 *Foo 类型的参数。我们通过 fooObject.foofunc = foo1 的方式将函数赋值给结构体字段。在调用时，必须显式地将 fooObject 的地址 (&fooObject) 传递给 fooObject.foofunc，以便函数能够访问和操作 fooObject 的内部数据。
在结构体中嵌入函数切片
除了单个函数，我们还可以将一个函数切片存储在结构体中。这种模式在需要按顺序执行一系列操作、实现命令模式或策略模式的变体时非常有用。
以下是关于 Bar 结构体如何嵌入并遍历函数切片的示例：
package main
import "fmt"
// 定义Bar结构体的函数类型
type BB func(*Bar)
// Bar结构体定义
type Bar struct {
barFuncs []BB // 存储一个BB类型的函数切片
salary int
debt int
}
// 两个符合BB签名的普通函数，用于操作Bar实例
func barSalary(b *Bar) {
fmt.Println("[barSalary] My salary is ", b.salary)
}
func barDebt(b *Bar) {
fmt.Println("[barDebt] My debt is ", b.debt)
}
func main() {
// 创建一个BB类型的函数切片并填充
barFuncList := make([]BB, 2) // 创建一个长度为2的BB类型切片
barFuncList[0] = barSalary
barFuncList[1] = barDebt
// 实例化Bar，并将函数切片赋值给barFuncs字段
barObject := Bar{
salary: 45000,
debt: 200,
barFuncs: barFuncList, // 将函数切片赋值给barFuncs字段
}
// 遍历函数切片并依次调用每个函数
for i := 0; i < len(barObject.barFuncs); i++ {
barObject.barFuncs[i](&barObject) // 每次调用都传入barObject的指针
}
}在这个例子中，barFuncList 是一个 BB 类型的切片，其中存储了 barSalary 和 barDebt 两个函数。在创建 barObject 时，我们将 barFuncList 赋值给 barFuncs 字段。随后，通过循环遍历 barFuncs 切片，我们可以按顺序调用其中存储的每个函数，并同样传入 &barObject 以便它们能够操作 barObject 的数据。
完整示例代码
为了更全面地展示上述概念，以下是一个完整的Go程序示例，结合了 Foo 和 Bar 结构体的所有代码：
package main
import (
"fmt"
)
// 定义Foo结构体的函数类型
type FF func(*Foo)
// Foo结构体定义
type Foo struct {
foofunc FF
name string
age int
}
// 两个操作Foo实例的函数
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)
}
// 定义Bar结构体的函数类型
type BB func(*Bar)
// Bar结构体定义
type Bar struct {
barFuncs []BB
salary int
debt int
}
// 两个操作Bar实例的函数
func barSalary(b *Bar) {
fmt.Println("[barSalary] My salary is ", b.salary)
}
func barDebt(b *Bar) {
fmt.Println("[barDebt] My debt is ", b.debt)
}
func main() {
// Foo结构体示例
fooObject := Foo{
name: "micheal",
}
fooObject.foofunc = foo1 // 赋值foo1
fooObject.foofunc(&fooObject) // 调用
fooObject = Foo{ // 重新初始化并赋值foo2
name: "lisa",
age: 22,
}
fooObject.foofunc = foo2 // 赋值foo2
fooObject.foofunc(&fooObject) // 调用
fmt.Println("--------------------")
// Bar结构体示例
barFuncList := make([]BB, 2) // 创建函数切片
barFuncList[0] = barSalary
barFuncList[1] = barDebt
barObject := Bar{
salary: 45000,
debt: 200, 
