Golang中如何从字符串获取对象的值？

Golang中如何从字符串获取对象的值？ 我有一个字符串值，希望能在运行的程序中将其转换为实际的对象。这个字符串将从配置文件中读取。例如，字符串 "os:Stdin" 应该可以通过某种方式处理，以获取实际的变量 os.Stdin。这在 Go 中可能实现吗？reflect 包似乎只对已存在的对象起作用；我也查看了 go/importer 包，但它主要处理源代码级别的信息，似乎不允许你从那里连接到内存中已存在的对象。其他语言的等价功能是 Java 中的 Class.forName(...) 或 C# 中的 Assembly.GetType(...)。有人能提供一些有用的指引吗？我知道 plugin 包，但据我所知，它在 Windows 上不起作用。


更多关于Golang中如何从字符串获取对象的值？的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

好的，感谢您的回复！很遗憾这无法实现——不幸的是，这涉及到一个通用配置库，开发者可以在配置中指定他们自己程序中会有的内容。该库可能无法知晓这些内容是什么，因此查找方法不可用。唉，好吧。

更多关于Golang中如何从字符串获取对象的值？的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你好，Vinay，在 Go 中仅通过名称访问对象（我指的是函数、类型、变量）是不可能的。Go 在设计上会省略那些可以证明无法访问的代码和数据。仅通过名称就能访问函数、变量或类型会破坏 Go 工具追踪它们使用位置的能力。

一种“变通方法”是，如果你知道选项的集合，你可以在代码中构建一个查找表，例如：

var names = map[string]interface{} {
    "os": map[string]interface{} {
        "Stdin": os.Stdin,
    }
}

// GetName 通过名称获取对象。它没有正确地循环，
// 但你应该能明白这个思路！
func GetName(name string) (interface{}, bool) {
    m := names
    var v interface{}
    for _, part := range strings.Split(name, ".") {
        var ok bool
        v, ok = m[part]
        if !ok {
            return nil, false
        }
        m, ok = v.(map[string]interface{})
        if ok {
            continue
        }
    }
    return v, true
}

不过，我不建议这样做。

在Go中，可以通过reflect包结合unsafe包来实现从字符串获取对象的值，但需要注意这通常不是推荐的做法，因为它绕过了类型安全。以下是一个示例，展示如何从字符串"os:Stdin"获取os.Stdin的值：

package main

import (
    "fmt"
    "os"
    "reflect"
    "strings"
    "unsafe"
)

func getValueFromString(path string) (reflect.Value, error) {
    parts := strings.Split(path, ":")
    if len(parts) != 2 {
        return reflect.Value{}, fmt.Errorf("invalid format, expected 'package:variable'")
    }

    pkgName, varName := parts[0], parts[1]

    // 获取包的符号表（仅适用于已导入的包）
    pkg := reflect.ValueOf(os.Stdin).Type().PkgPath()
    if pkg != pkgName {
        return reflect.Value{}, fmt.Errorf("package %s not found or not imported", pkgName)
    }

    // 通过反射获取包级别的变量
    var value reflect.Value
    switch pkgName {
    case "os":
        switch varName {
        case "Stdin":
            value = reflect.ValueOf(os.Stdin)
        case "Stdout":
            value = reflect.ValueOf(os.Stdout)
        case "Stderr":
            value = reflect.ValueOf(os.Stderr)
        default:
            return reflect.Value{}, fmt.Errorf("variable %s not found in package %s", varName, pkgName)
        }
    default:
        return reflect.Value{}, fmt.Errorf("package %s not supported", pkgName)
    }

    return value, nil
}

func main() {
    str := "os:Stdin"
    val, err := getValueFromString(str)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 使用unsafe.Pointer获取底层值（谨慎使用）
    ptr := unsafe.Pointer(val.UnsafeAddr())
    fmt.Printf("Value address: %v\n", ptr)
    fmt.Printf("Value type: %v\n", val.Type())
}

如果需要动态加载包，可以考虑使用go/ast和go/parser包解析源代码，但这通常用于静态分析。对于运行时动态访问，建议使用映射表（map）来关联字符串和对象：

package main

import (
    "fmt"
    "os"
)

var registry = map[string]interface{}{
    "os:Stdin":  os.Stdin,
    "os:Stdout": os.Stdout,
    "os:Stderr": os.Stderr,
}

func getObject(key string) (interface{}, bool) {
    obj, ok := registry[key]
    return obj, ok
}

func main() {
    key := "os:Stdin"
    if obj, ok := getObject(key); ok {
        fmt.Printf("Object: %v\n", obj)
        fmt.Printf("Type: %T\n", obj)
    } else {
        fmt.Println("Object not found")
    }
}

这种方法更安全，且不依赖反射或unsafe操作。

回到顶部