How Can I Discover Package Types Dynamically in Go?

Finding Package Types Dynamically

Despite the absence of type discovery mechanisms in the reflect package, other methods exist for discovering exported types, particularly structs, at runtime.

Go 1.5 and Later

In Go 1.5 and above, the types and importer packages can assist in this task. The following code snippet demonstrates the process:

package main

import (
    "fmt"
    "go/importer"
)

func main() {
    pkg, err := importer.Default().Import("time")
    if err != nil {
        fmt.Printf("error: %s\n", err.Error())
        return
    }
    for _, declName := range pkg.Scope().Names() {
        fmt.Println(declName)
    }
}

Pre-1.5 Versions

Before Go 1.5, the ast package provides the only non-hacky approach to this problem. By compiling the source code, this package can extract type information:

package main

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

func main() {
    fset := token.NewFileSet()
    node, err := parser.ParseFile(fset, "time.go", nil, parser.ParseComments)
    if err != nil {
        fmt.Printf("error: %s\n", err.Error())
        return
    }
    ast.Inspect(node, func(n ast.Node) bool {
        if n, ok := n.(*ast.TypeSpec); ok {
            fmt.Println(n.Name.Name)
        }
        return true
    })
}

These techniques allow for the discovery of exported types, especially structs, within running Go packages, enabling further analysis and instantiation of instances.

The above is the detailed content of How Can I Discover Package Types Dynamically in Go?. For more information, please follow other related articles on the PHP Chinese website!