Golang中如何在一个函数内执行多个函数

Golang中如何在一个函数内执行多个函数 我需要实现一个如下形式的函数：

func appendFunc (dst func ([] int), src ... func ([] int)) func ([] int)

这个函数接收一个用于处理切片的目标函数 dst 作为参数，以及不限数量的其他处理函数 src，这些函数需要“附加”到 dst 函数上，并返回一个新的函数。

我卡在了这段代码上：

func appendFunc(src ...func([]int)) func() {
	numsSlice := []int{9, 0, 1, 8, 7, 2, 3, 4, 6, 5}
	return func() {
		fmt.Println("this wont be printed")
		for _, i := range src {
			i(numsSlice)
		}
	}
}
func main() {
	appendFunc(SortSlice, IncrementOdd, PrintSlice, ReverseSlice)
}

为什么它什么都没显示？


更多关于Golang中如何在一个函数内执行多个函数的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

谢谢！现在它可以工作了！ 解决方案是：

appendFunc(SortSlice, IncrementOdd, PrintSlice, ReverseSlice)()

更多关于Golang中如何在一个函数内执行多个函数的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你是如何调用这个函数的？

抱歉，我刚才实际上没有问到点子上。我的意思是，你的 appendFunc 函数本身返回一个函数，但你并没有调用这个返回的函数。

你的代码没有显示任何输出是因为 appendFunc 返回了一个函数，但你并没有调用这个返回的函数。在 Go 中，函数作为一等公民可以像其他值一样传递和返回，但你需要显式调用它们才能执行。

以下是修正后的代码：

package main

import (
	"fmt"
	"sort"
)

func appendFunc(dst func([]int), src ...func([]int)) func([]int) {
	return func(slice []int) {
		// 先执行目标函数
		dst(slice)
		// 然后依次执行附加函数
		for _, f := range src {
			f(slice)
		}
	}
}

// 示例函数定义
func SortSlice(slice []int) {
	sort.Ints(slice)
	fmt.Println("Sorted:", slice)
}

func IncrementOdd(slice []int) {
	for i := range slice {
		if slice[i]%2 != 0 {
			slice[i]++
		}
	}
	fmt.Println("Incremented odd:", slice)
}

func PrintSlice(slice []int) {
	fmt.Println("Current:", slice)
}

func ReverseSlice(slice []int) {
	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
		slice[i], slice[j] = slice[j], slice[i]
	}
	fmt.Println("Reversed:", slice)
}

func main() {
	// 创建组合函数
	combinedFunc := appendFunc(SortSlice, IncrementOdd, PrintSlice, ReverseSlice)
	
	// 准备测试数据
	nums := []int{9, 0, 1, 8, 7, 2, 3, 4, 6, 5}
	
	// 调用组合函数
	combinedFunc(nums)
}

输出结果：

Sorted: [0 1 2 3 4 5 6 7 8 9]
Incremented odd: [0 2 2 4 4 6 6 8 8 10]
Current: [0 2 2 4 4 6 6 8 8 10]
Reversed: [10 8 8 6 6 4 4 2 2 0]

关键点：

  1. appendFunc 返回的是一个闭包函数，需要被调用才能执行
  2. 返回的函数接收 []int 参数，并在内部依次调用所有函数
  3. 所有函数共享同一个切片，所以后续函数能看到前面函数的修改结果

如果你想让函数链式执行但保持原始切片不变，可以修改为创建副本：

func appendFunc(dst func([]int), src ...func([]int)) func([]int) {
	return func(slice []int) {
		// 创建副本以避免修改原始数据
		copySlice := make([]int, len(slice))
		copy(copySlice, slice)
		
		dst(copySlice)
		for _, f := range src {
			f(copySlice)
		}
	}
}
回到顶部