Go中没有函数指针，所谓“函数指针数组”实为[]func()或[N]func()这类函数值切片/数组；声明需统一签名，填充用函数名（不带括号），调用可顺序或并发，切片比map更适序贯执行。

什么是函数指针数组？Go 里没有“函数指针”这个概念

Go 没有 C 那样的函数指针（void (*func_ptr)()），但可以用 func() 类型变量来存储函数值，这些变量本身可放入切片或数组。所谓“函数指针数组”，实际是 []func() 或 [N]func() 这类函数值切片/数组。

误用 C 思维容易踩坑：比如试图取函数地址（&myFunc）再强转——Go 不允许；或者期望函数值能像指针一样被修改后影响原函数——函数值是只读的副本，不影响定义处。

如何声明和填充函数值切片

最常用的是切片而非固定数组，因为长度更灵活。注意函数签名必须完全一致，否则类型不匹配。

• 声明：用 []func(int) string 表示“参数为 int、返回 string 的函数”的切片
• 填充：直接把函数名（不带括号）赋进去，如 handlers = append(handlers, handleUser, handleOrder)
• 不能混入签名不同的函数，哪怕只差一个 error 返回值，编译器立刻报错：cannot use handleFile (type func(string) (string, error)) as type func(string) string in append

func handleUser(id int) string { return "user:" + strconv.Itoa(id) }
func handleOrder(id int) string { return "order:" + strconv.Itoa(id) }
handlers := []func(int) string{handleUser, handleOrder}
for _, f := range handlers {
fmt.Println(f(123))
}

批量调用时如何传参并收集结果

直接遍历调用没问题，但若需统一传参、捕获 panic、超时控制或并发执行，就得封装逻辑。常见错误是忽略返回值类型差异或 panic 导致后续函数跳过。

• 同步顺序调用：用 for range 最安全，每个函数独立执行
• 并发调用：用 goroutine + channel 收集结果，但要注意闭包中变量捕获问题（别在循环里直接用 f，应传参）
• 带错误处理：建议函数签名统一返回 error，或用 struct{ result string; err error } 包装

type Result struct{ Value string; Err error }
results := make(chan Result, len(handlers))
for _, f := range handlers {
go func(fn func(int) string, id int) {
defer func() {
if r := recover(); r != nil {
results <- Result{Err: fmt.Errorf("panic: %v", r)}
}
}()
results <- Result{Value: fn(id)}
}(f, 123)
}
for i := 0; i < len(handlers); i++ {
r := <-results
if r.Err != nil {
log.Printf("failed: %v", r.Err)
} else {
fmt.Println(r.Value)
}
}

为什么不用 map[string]func() 而用切片？

切片适合“按序批量执行”，map 更适合“按名查找单个函数”。但 map 有隐藏成本：哈希计算、扩容、键不存在时的零值返回，容易掩盖逻辑错误。

• 如果调用顺序重要（比如中间件链），必须用切片，[]func() 天然保序
• 如果需要动态增删，切片配合 append/copy 比 map 更轻量
• map 键是字符串时，拼写错误（如 "handelUser"）只有运行时才暴露，切片索引越界则编译期或 panic 更早发现

真正复杂的需求（如条件跳过、上下文透传、依赖注入）该用专门的调度器或中间件框架，而不是硬塞进函数切片里。