Go 语言中把方法作为参数传入_go 方法参数-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_57836225/article/details/145041482

在 Go 语言中，函数是一等公民，这意味着函数可以像其他数据类型一样被赋值给变量、作为参数传递给其他函数，或者作为函数的返回值。把方法作为参数传入其他函数，是一种非常强大且灵活的编程技巧，它能让代码更加模块化、可复用，并且可以根据不同的业务逻辑动态地改变行为。

1. 函数类型的定义

首先，我们需要明确在 Go 语言中函数也是有类型的，函数类型由它的参数列表和返回值列表共同决定。例如：

// 定义一个函数类型，它接受一个int类型参数，返回一个int类型值
type IntFunc func(int) int

这里定义的 IntFunc 就是一种函数类型，后续我们就可以按照这个类型来声明变量、传递参数等操作。

2. 把普通函数作为参数传入

下面通过一个简单的示例来展示如何把普通函数作为参数传入另一个函数。我们定义两个函数，一个用于对传入的整数加 1，另一个用于对传入的整数乘 2，然后有一个通用的函数可以接收这些不同的操作函数，并应用到给定的整数上。

package main

import "fmt"

// 定义函数类型，接受一个int参数，返回一个int结果
type MathOp func(int) int

// 加1操作的函数
func addOne(num int) int {
    return num + 1
}

// 乘2操作的函数
func multiplyByTwo(num int) int {
    return num * 2
}

// 通用的执行数学操作的函数，接收一个MathOp类型的函数作为参数
func doMathOperation(num int, op MathOp) int {
    return op(num)
}

func main() {
    num := 5
    // 传入addOne函数作为参数，执行加1操作
    result1 := doMathOperation(num, addOne)
    fmt.Printf("对 %d 执行加1操作后的结果是: %d\n", num, result1)

    // 传入multiplyByTwo函数作为参数，执行乘2操作
    result2 := doMathOperation(num, multiplyByTwo)
    fmt.Printf("对 %d 执行乘2操作后的结果是: %d\n", num, result2)
}

在上述代码中：

首先定义了 MathOp 函数类型，它规范了后续作为参数传入的函数的格式，即都需要接受一个 int 类型参数并返回一个 int 类型结果。
addOne 和 multiplyByTwo 函数分别实现了不同的数学操作，它们的参数和返回值类型都符合 MathOp 函数类型的定义。
doMathOperation 函数是核心的通用函数，它接收一个整数和一个 MathOp 类型的函数作为参数，在函数内部通过 op(num) 调用传入的函数，并将结果返回。这样，通过传入不同的函数，就可以在 doMathOperation 函数中执行不同的数学操作，体现了很高的灵活性和代码复用性。

3. 结合值传递和引用传递的示例

我们可以进一步扩展上述示例，结合值传递和引用传递的特点，展示更复杂一些的把函数作为参数传入的情况。假设我们有一个场景，需要对一个整数数组进行不同的操作，操作可以是修改数组元素的值（类似引用传递的效果，直接影响原始数据），也可以是基于数组元素进行计算但不改变原始数组（类似值传递的效果）。

package main

import "fmt"

// 定义函数类型，接受一个[]int切片参数，返回一个[]int切片结果
type SliceOp func([]int) []int

// 对切片每个元素加1的操作函数（类似值传递，不改变原始切片）
func addOneToSlice(slice []int) []int {
    result := make([]int, len(slice))
    for i, v := range slice {
        result[i] = v + 1
    }
    return result
}

// 对切片每个元素乘2的操作函数（类似值传递，不改变原始切片）
func multiplySliceByTwo(slice []int) []int {
    result := make([]int, len(slice))
    for i, v := range slice {
        result[i] = v * 2
    }
    return result
}

// 直接修改切片元素的操作函数（类似引用传递，改变原始切片）
func modifySliceInPlace(slice []int) []int {
    for i := range slice {
        slice[i] *= 3
    }
    return slice
}

// 通用的对切片执行操作的函数，接收一个SliceOp类型的函数作为参数
func doSliceOperation(slice []int, op SliceOp) []int {
    return op(slice)
}

func main() {
    slice := []int{1, 2, 3}
    // 传入addOneToSlice函数作为参数，执行每个元素加1操作
    result1 := doSliceOperation(slice, addOneToSlice)
    fmt.Printf("对切片 %v 执行每个元素加1操作后的结果是: %v\n", slice, result1)
    fmt.Printf("原始切片未改变，仍为: %v\n", slice)

    // 传入multiplySliceByTwo函数作为参数，执行每个元素乘2操作
    result2 := doSliceOperation(slice, multiplySliceByTwo)
    fmt.Printf("对切片 %v 执行每个元素乘2操作后的结果是: %v\n", slice, result2)
    fmt.Printf("原始切片未改变，仍为: %v\n", slice)

    // 传入modifySliceInPlace函数作为参数，执行修改元素的操作
    result3 := doSliceOperation(slice, modifySliceInPlace)
    fmt.Printf("对切片 %v 执行修改元素操作后的结果是: %v\n", slice, result3)
    fmt.Printf("原始切片已被改变，现为: %v\n", slice)
}

在这个示例中：

定义了 SliceOp 函数类型，用于规范对整数切片进行操作的函数格式，即接受一个 []int 切片参数并返回一个 []int 切片结果。
addOneToSlice、multiplySliceByTwo 和 modifySliceInPlace 这几个函数分别实现了不同的对切片的操作，前两个是创建新的切片进行计算，不改变原始切片（类似值传递的效果），而 modifySliceInPlace 函数直接修改传入的切片元素（类似引用传递的效果）。
doSliceOperation 函数作为通用的操作函数，接收一个切片和一个 SliceOp 类型的函数作为参数，通过调用传入的函数 op(slice) 来执行具体的操作，并返回结果切片。