Go语言中检查函数或方法存在性的策略与实践

package main

import "fmt"

// Greeter 是一个简单的结构体
type Greeter struct {
    Name string
}

// Hello 方法定义在 Greeter 类型上
func (g *Greeter) Hello() string {
    return "hello " + g.Name
}

func main() {
    var x interface{} // 声明一个 interface{} 类型的变量

    // 将 Greeter 实例赋值给 x
    x = Greeter{Name: "Paolo"}

    // 使用类型断言检查 x 是否为 Greeter 类型
    // g 将是 Greeter 类型的值，ok 是一个布尔值，表示断言是否成功
    if g, ok := x.(Greeter); ok {
        // 如果断言成功，我们就可以安全地调用 Greeter 类型特有的 Hello() 方法
        fmt.Println(g.Hello())
    } else {
        fmt.Println("x 不是 Greeter 类型")
    }

    // 尝试将一个不同类型的值赋给 x
    x = 123
    if g, ok := x.(Greeter); ok {
        fmt.Println(g.Hello())
    } else {
        fmt.Println("x 不是 Greeter 类型 (当前值为整数)")
    }
}

package main

import (
    "fmt"
    "reflect"
)

// Speaker 结构体
type Speaker struct {
    Greeting string
}

// Greet 方法
func (s Speaker) Greet(name string) string {
    return fmt.Sprintf("%s, %s!", s.Greeting, name)
}

// SayGoodbye 方法
func (s Speaker) SayGoodbye() string {
    return "Goodbye!"
}

func main() {
    s := Speaker{Greeting: "Hello"}
    sValue := reflect.ValueOf(s) // 获取 Speaker 实例的反射值

    // 检查 Greet 方法是否存在
    greetMethod := sValue.MethodByName("Greet")
    if greetMethod.IsValid() {
        fmt.Println("方法 'Greet' 存在。")
        // 调用 Greet 方法，需要传入参数的反射值
        // 注意：这里需要一个 []reflect.Value 切片作为参数
        args := []reflect.Value{reflect.ValueOf("World")}
        result := greetMethod.Call(args)
        fmt.Println("调用 'Greet' 结果:", result[0].Interface()) // 结果是 []reflect.Value
    } else {
        fmt.Println("方法 'Greet' 不存在。")
    }

    // 检查一个不存在的方法
    unknownMethod := sValue.MethodByName("NotExist")
    if unknownMethod.IsValid() {
        fmt.Println("方法 'NotExist' 存在。")
    } else {
        fmt.Println("方法 'NotExist' 不存在。")
    }

    // 检查 SayGoodbye 方法是否存在并调用
    goodbyeMethod := sValue.MethodByName("SayGoodbye")
    if goodbyeMethod.IsValid() {
        fmt.Println("方法 'SayGoodbye' 存在。")
        result := goodbyeMethod.Call(nil) // 没有参数，传入 nil
        fmt.Println("调用 'SayGoodbye' 结果:", result[0].Interface())
    } else {
        fmt.Println("方法 'SayGoodbye' 不存在。")
    }
}

package main

import (
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
    "log"
)

func main() {
    src := `
package main

import "fmt"

func MyGlobalFunction() {
    fmt.Println("This is a global function.")
}

type MyStruct struct {}

func (m MyStruct) MyMethod() {
    fmt.Println("This is a method.")
}

func anotherFunction() {} // 小写字母开头的函数
`

    fset := token.NewFileSet() // 用于管理源文件位置信息
    // 解析源代码，parser.ParseComments 会解析注释
    node, err := parser.ParseFile(fset, "", src, parser.ParseComments)
    if err != nil {
        log.Fatalf("解析文件失败: %v", err)
    }

    // 遍历AST，查找函数和方法
    for _, decl := range node.Decls {
        switch d := decl.(type) {
        case *ast.FuncDecl: // 这是一个函数或方法声明
            funcName := d.Name.Name
            if d.Recv == nil { // 没有接收者，是普通函数
                fmt.Printf("发现全局函数: %s\n", funcName)
                if funcName == "MyGlobalFunction" {
                    fmt.Println(" -> 找到了 'MyGlobalFunction'")
                }
            } else { // 有接收者，是方法
                // 获取接收者类型，例如 (*MyStruct) 或 (MyStruct)
                recvType := ""
                if len(d.Recv.List) > 0 {
                    if ident, ok := d.Recv.List[0].Type.(*ast.Ident); ok {
                        recvType = ident.Name
                    } else if starExpr, ok := d.Recv.List[0].Type.(*ast.StarExpr); ok {
                        if ident, ok := starExpr.X.(*ast.Ident); ok {
                            recvType = "*" + ident.Name
                        }
                    }
                }
                fmt.Printf("发现方法: %s.%s\n", recvType, funcName)
                if funcName == "MyMethod" && recvType == "MyStruct" {
                    fmt.Println(" -> 找到了 'MyStruct.MyMethod'")
                }
            }
        }
    }
}