Gehen - Kopieren Sie alle gemeinsamen Felder zwischen Strukturen

Hier ist eine Lösung mit der spiegelung. Sie haben weitere entwickeln, wenn Sie mehr komplexe Strukturen mit eingebetteten struct-Felder und so.

http://play.golang.org/p/iTaDgsdSaI

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type M map[string]interface{} //just an alias

var Record = []byte(`{ "bit_size": 8, "secret_key": false }`)

type DB struct {
    NumBits int  `json:"bit_size"`
    Secret  bool `json:"secret_key"`
}

type User struct {
    NumBits int `json:"num_bits"`
}

func main() {
    d := new(DB)
    e := json.Unmarshal(Record, d)
    if e != nil {
        panic(e)
    }
    m := mapFields(d)
    fmt.Println("Mapped fields: ", m)
    u := new(User)
    o := applyMap(u, m)
    fmt.Println("Applied map: ", o)
    j, e := json.Marshal(o)
    if e != nil {
        panic(e)
    }
    fmt.Println("Output JSON: ", string(j))
}

func applyMap(u *User, m M) M {
    t := reflect.TypeOf(u).Elem()
    o := make(M)
    for i := 0; i < t.NumField(); i++ {
        f := t.FieldByIndex([]int{i})
        //skip unexported fields
        if f.PkgPath != "" {
            continue
        }
        if x, ok := m[f.Name]; ok {
            k := f.Tag.Get("json")
            o[k] = x
        }
    }
    return o
}

func mapFields(x *DB) M {
    o := make(M)
    v := reflect.ValueOf(x).Elem()
    t := v.Type()
    for i := 0; i < v.NumField(); i++ {
        f := t.FieldByIndex([]int{i})
        //skip unexported fields
        if f.PkgPath != "" {
            continue
        }
        o[f.Name] = v.FieldByIndex([]int{i}).Interface()
    }
    return o
}

buf := bytes.Buffer{}
err := gob.NewEncoder(&buf).Encode(&DbVar)
if err != nil {
    return err
}
u := User{}
err = gob.NewDecoder(&buf).Decode(&u)
if err != nil {
    return err
}

Hier ist eine Lösung ohne Reflexion, unsicher, oder eine Funktion pro struct. Das Beispiel ist ein wenig kompliziert, und vielleicht würden Sie nicht brauchen, um es tun nur so, aber der Schlüssel ist mit einem map[string]interface {}, um Weg von einer Struktur mit Feld-tags. Sie können möglicherweise verwenden Sie die Idee, eine ähnliche Lösung.

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

//example full database record
var dbj = `{ "bit_size": 8, "secret_key": false }`

//User type has only the fields going to the API
type User struct {
    //tag still specifies internal name, not API name
    NumBits int `json:"bit_size"`
}

//mapping from internal field names to API field names.
//(you could have more than one mapping, or even construct this
//at run time)
var ApiField = map[string]string{
    //internal: API
    "bit_size": "num_bits",
    //...
}

func main() {
    fmt.Println(dbj)
    //select user fields from full db record by unmarshalling
    var u User
    if err := json.Unmarshal([]byte(dbj), &u); err != nil {
        log.Fatal(err)
    }
    //remarshal from User struct back to json
    exportable, err := json.Marshal(u)
    if err != nil {
        log.Fatal(err)
    }
    //unmarshal into a map this time, to shrug field tags.
    type jmap map[string]interface{}
    mInternal := jmap{}
    if err := json.Unmarshal(exportable, &mInternal); err != nil {
        log.Fatal(err)
    }
    //translate field names
    mExportable := jmap{}
    for internalField, v := range mInternal {
        mExportable[ApiField[internalField]] = v
    }
    //marshal final result with API field names
    if exportable, err = json.Marshal(mExportable); err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(exportable))
}

Ausgabe:

{ "bit_size": 8, "secret_key": false }

{"num_bits":8}

Edit: Weitere Erläuterung. Als Tom Notizen in einem Kommentar, es wird die Reflexion hinter dem code. Das Ziel hier ist, halten Sie den code einfach über die verfügbaren Funktionen der Bibliothek. Paket json bietet derzeit zwei Möglichkeiten, um mit Daten zu arbeiten, struct-tags und-Karten [string]interface{}. Die struct-tags können Sie Felder auswählen, aber zwingen Sie statisch wählen Sie eine einzelne json-Feld-Namen. Die Karten lassen Sie Sie auswählen, Feldnamen zur Laufzeit, aber nicht, welche Felder Marschall. Es wäre schön, wenn die json-Paket lassen Sie beides auf einmal, aber es funktioniert nicht. Hier die Antwort zeigt nur, dass die beiden Techniken erhalten und wie Sie verfasst werden kann, in eine Lösung des Beispiel-Problems in den OP.

Können Sie werfen Strukturen, wenn Sie haben die gleichen Feldnamen und Typen, effektiv Neuzuweisen Feld tags:

package main

import "encoding/json"

type DB struct {
    dbNumBits
    Secret bool `json:"secret_key"`
}

type dbNumBits struct {
    NumBits int `json:"bit_size"`
}

type User struct {
    NumBits int `json:"num_bits"`
}

var Record = []byte(`{ "bit_size": 8, "secret_key": false }`)

func main() {
    d := new(DB)
    e := json.Unmarshal(Record, d)
    if e != nil {
        panic(e)
    }

    var u User = User(d.dbNumBits)
    println(u.NumBits)
}

https://play.golang.org/p/uX-IIgL-rjc