Question

有没有办法在Golang中将struct转换为值数组？

例如，如果我有这种结构（不只是这一个）：

type Model struct {
    Id        bson.ObjectId   `bson:"_id,omitempty"`
    CreatedAt time.Time       `bson:",omitempty"`
    UpdatedAt time.Time       `bson:",omitempty"`
    DeletedAt time.Time       `bson:",omitempty"`
    CreatedBy bson.ObjectId   `bson:",omitempty"`
    UpdatedBy bson.ObjectId   `bson:",omitempty"`
    DeletedBy bson.ObjectId   `bson:",omitempty"`
    Logs      []bson.ObjectId `bson:",omitempty"`
}

type User struct {
    Name  string `bson:"name"`
    Model `bson:",inline"`
}

案例是，我通常使用以下格式将JSON发送到浏览器：

var iota = -1
var data = {
  NAME: ++iota, ID: ++iota, CREATED_AT: ++iota, UPDATED_AT: ++iota, DELETED_AT: ++iota, // and so on
  rows: [['kiz',1,'2014-01-01','2014-01-01','2014-01-01'],
         ['yui',2,'2014-01-01','2014-01-01','2014-01-01'],
         ['ham',3,'2014-01-01','2014-01-01','2014-01-01'] // and so on
        ]
};

而不是：

var data = {
  rows: [{NAME:'kiz',ID:1,CreatedAt:'2014-01-01',UpdatedAt:'2014-01-01',DeletedAt:'2014-01-01'},
         {NAME:'yui',ID:2,CreatedAt:'2014-01-01',UpdatedAt:'2014-01-01',DeletedAt:'2014-01-01'},
         {NAME:'ham',ID:3,CreatedAt:'2014-01-01',UpdatedAt:'2014-01-01',DeletedAt:'2014-01-01'} // and so on
        ]
}

以下是我尝试的内容：

import (
    "github.com/kr/pretty"
    //"gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
    "reflect"
    "runtime"
    "strings"
    "time"
)

// copy the model from above

func Explain(variable interface{}) {
    _, file, line, _ := runtime.Caller(1)
    //res, _ := json.MarshalIndent(variable, "   ", "  ")
    res := pretty.Formatter(variable)
    fmt.Printf("%s:%d: %# v\n", file[len(FILE_PATH):], line, res)
    //spew.Dump(variable)
}

func s2a(i interface{}) []interface{} { // taken from https://gist.github.com/tonyhb/5819315
    iVal := reflect.ValueOf(i).Elem()
    //typ := iVal.Type()
    values := make([]interface{}, 0, iVal.NumField())
    for i := 0; i < iVal.NumField(); i++ {
        f := iVal.Field(i)
        //tag := typ.Field(i).Tag.Get("tagname")
        //fmt.Println(tag)
        // name := typ.Field(i).Name
        v := f.Interface()
        switch v.(type) {
        case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, string, []byte, time.Time:
            // do nothing
        // case struct{}: // how to catch any embeeded struct?
        case Model: // Model (or any embedded/nameless struct) should also converted to array
            //arr := s2a() // invalid type assertion: f.(Model) (non-interface type reflect.Value on left)
            //arr := s2a(f.Addr().(&Model)) // invalid type assertion: f.Addr().(&Model) (non-interface type reflect.Value on left)
            // umm.. how to convert f back to Model?
            //for _, e := range arr {
                values = append(values, e)
            //}
        default: // struct? but also interface and map T_T
            //v = s2a(&v)
        }
        values = append(values, v)
    }
    return values
}

func main() {
    //sess, err := mgo.Dial("127.0.0.1")
    //Check(err, "unable to connect")
    //db := sess.DB("test")
    //coll := db.C("coll1")
    user := User{}
    user.Id = bson.NewObjectId()
    user.Name = "kis"
    //changeInfo, err := coll.UpsertId(user.Id, user)
    //Check(err, "failed to insert")
    //Explain(changeInfo)
    //Explain(s2a(changeInfo))
    user.Name = "test"
    Explain(user)
    Explain(s2a(&user))
    //err = coll.FindId(user.Id).One(&user)
    //Check(err, "failed to fetch")
    //Explain(user)
    //Explain(s2a(&user))
    user.CreatedAt = time.Now()
    //err = coll.UpdateId(user.Id, user)
    //Check(err, "failed to update")
    Explain(changeInfo)
    Explain(s2a(&user))
    user.CreatedAt = user.DeletedAt
    //err = coll.FindId(user.Id).One(&user)
    //Check(err, "failed to fetch")
    Explain(user)
    Explain(s2a(&user))
}

是否有简单/快速的方法将struct转换为数组（如果有嵌入/内部的struct，也转换为数组）？

Answer 1

使用reflect包。

这里有一些playground code可以为一个记录（任何结构类型）工作，你可以重构它来处理一段记录。

编辑:(复制粘贴好的措施）

package main

import "fmt"
import "strings"
import "reflect"

type X struct {
    Y string
    Z int
}

func main() {
    data := X{"yval",3}
    expectedResult := `{"Y": 0, "Z": 1, "rows": [["yval", 3]]}`

    fmt.Println(convert(data))
    fmt.Println(expectedResult)
}

func convert(data interface{}) string {
    v := reflect.ValueOf(data)
    n := v.NumField()

    st := reflect.TypeOf(data)
    headers := make([]string, n)
    for i := 0; i < n; i++ {
        headers[i] = fmt.Sprintf(`"%s": %d`, st.Field(i).Name, i)
    }

    rowContents := make([]string, n)
    for i := 0; i < n; i++ {
        x := v.Field(i)
        s := fmt.Sprintf("%v", x.Interface())
        if x.Type().String() == "string" {
            s = `"` + s + `"`
        }
        rowContents[i] = s
    }

    return "{" + strings.Join(headers, ", ") + `, "rows": [[` + strings.Join(rowContents, ", ") + "]]}"
}

Answer 2

如果您乐意为数组表示中的字段指定固定顺序，则可以通过实现json.Marshaler interface来自定义其表示来实现此目的。例如：

func (u User) MarshalJSON() ([]byte, error) {
    a := []interface{}{
        u.Name,
        u.Id,
        ...,
    }
    return json.Marshal(a)
}

现在，当您编组此类型的变量时，它们将表示为数组。如果你想反过来（将数组解组到这个结构中），你还需要实现json.Unmarshaler interface。这可以通过类似的方式完成，使用json.Unmarshal解码为[]interface{}切片，然后拉出值。确保声明UnmarshalJSON采用指针接收器，否则您的代码将无效（您最终将更新结构的副本而不是结构本身）。

Answer 3

为什么不使用reflect.Kind（）？这是游乐场：http://play.golang.org/p/YjbsnB4eln

Golang，将嵌入式结构转换为数组

3 个答案: