以编程方式填充 golang 结构

Question

我有一个包含多种类型数据记录的文件，我需要将其解析为结构。

如果能了解一种按记录类型填充结构的惯用方法（如果存在），我将不胜感激。类似于 python 的 namedtuple(*fields) 构造函数。

package main

import (
    "fmt"
    "strconv"
    "strings"
)

type X interface{}

type HDR struct {
    typer, a string
    b        int
}

type BDY struct {
    typer, c string
    d        int
    e        string
}

var lines string = `HDR~two~5
BDY~four~6~five`

func sn(s string) int {
    i, _ := strconv.Atoi(s)
    return i
}

func main() {
    sl := strings.Split(lines, "\n")
    for _, l := range sl {
        fields := strings.Split(l, "~")
        var r X
        switch fields[0] {
        case "HDR":
            r = HDR{fields[0], fields[1], sn(fields[2])} // 1
        case "BDY":
            r = BDY{fields[0], fields[1], sn(fields[2]), fields[3]} // 2
        }
        fmt.Printf("%T : %v\n", r, r)
    }
}

我特别想知道标记为 // 1 和 // 2 的行是否可以方便地替换为代码，也许是某种允许结构本身处理类型转换的通用解码器。

Answer 1

使用 reflect 程序包以编程方式设置字段。

一个字段必须exported才能被反射包设置。通过将名称中的第一个符文大写来导出名称：

type HDR struct {
    Typer, A string
    B        int
}

type BDY struct {
    Typer, C string
    D        int
    E        string
}

创建名称到与名称关联的类型的映射：

var types = map[string]reflect.Type{
    "HDR": reflect.TypeOf((*HDR)(nil)).Elem(),
    "BDY": reflect.TypeOf((*BDY)(nil)).Elem(),
}

对于每一行，使用 types 映射创建一个类型的值：

for _, l := range strings.Split(lines, "\n") {
    fields := strings.Split(l, "~")
    t := types[fields[0]]
    v := reflect.New(t).Elem()
    ...
}

遍历行中的字段。获取字段值，将字符串转换为字段值的种类并设置字段值：

    for i, f := range fields {
        fv := v.Field(i)
        switch fv.Type().Kind() {
        case reflect.String:
            fv.SetString(f)
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            n, _ := strconv.ParseInt(f, 10, fv.Type().Bits())
            fv.SetInt(n)
        }
    }

这是该方法的基本概要。明显缺少错误处理：如果类型名称不是 types 中提到的类型之一，应用程序将崩溃；应用程序忽略解析整数返回的错误；如果数据中的字段多于结构中的字段，应用程序将崩溃；应用程序遇到不支持的字段种类时不报错；等等。

Run it on the Go Playground.

以编程方式填充 golang 结构

Programmatically fill golang struct

go

struct

go-reflect

go-interface