Go 语言中的头等函数：深度解析与实践

type MyFuncType func(param1Type, param2Type) returnType

type Stringy func() string

package main

import "fmt"

// 定义一个函数类型 Stringy
// 它的签名是：不接受任何参数，返回一个 string
type Stringy func() string

// foo 函数符合 Stringy 类型
func foo() string {
    return "这是 foo 函数返回的字符串"
}

// takesAFunction 接受一个 Stringy 类型的函数作为参数
func takesAFunction(f Stringy) {
    fmt.Printf("takesAFunction: 调用传入的函数并获取结果 -> %s\n", f())
}

func main() {
    fmt.Println("--- 1. 将函数作为参数传递 ---")
    // 将 foo 函数（它符合 Stringy 类型）作为参数传递给 takesAFunction
    takesAFunction(foo)
}

package main

import "fmt"

type Stringy func() string

// returnsAFunction 返回一个 Stringy 类型的函数
func returnsAFunction() Stringy {
    // 返回一个匿名函数，这个匿名函数符合 Stringy 类型
    return func() string {
        fmt.Println("Inner stringy function: 这是返回的匿名函数内部的打印")
        return "这是返回的匿名函数结果"
    }
}

func main() {
    fmt.Println("--- 2. 将函数作为返回值 ---")
    // 调用 returnsAFunction，它会返回一个 Stringy 类型的函数
    // 将返回的函数赋值给变量 returnedFunc
    returnedFunc := returnsAFunction()
    // 调用通过 returnsAFunction 得到的函数
    returnedFunc() // 此时会执行匿名函数内部的打印和返回操作
}

package main

import "fmt"

type Stringy func() string

func main() {
    fmt.Println("\n--- 3. 匿名函数赋值给变量 ---")
    // 定义一个匿名函数，并将其赋值给一个 Stringy 类型的变量
    // 这种方式常见于需要立即定义并使用的短小函数
    anonymousFuncVar := func() string {
        return "这是直接赋值给变量的匿名函数返回的字符串"
    }
    // 调用这个匿名函数变量
    fmt.Println(anonymousFuncVar())

    fmt.Println("\n--- 4. 直接调用匿名函数 ---")
    // 匿名函数也可以直接定义并调用，通常用于一次性任务
    func(msg string) {
        fmt.Printf("这是一个直接定义的匿名函数，参数是: %s\n", msg)
    }("Hello from anonymous function!") // 定义后立即调用

    fmt.Println("\n--- 5. 闭包示例 ---")
    // 闭包：匿名函数引用了外部作用域的变量
    counter := 0
    incrementer := func() int {
        counter++ // 引用并修改了外部的 counter 变量
        return counter
    }

    fmt.Printf("第一次调用 incrementer: %d\n", incrementer()) // 1
    fmt.Printf("第二次调用 incrementer: %d\n", incrementer()) // 2
    fmt.Printf("外部 counter 变量的值: %d\n", counter) // 2
}