Wie Sie die Schleife durch die Felder in einem Golang struct zu get-und set-Werte in einem erweiterbaren Weg?

Ich habe eine struct Person.

type Person struct {
    Firstname string       
    Lastname  string       
    Years     uint8       
}

Dann habe ich zwei Instanzen dieser Struktur, PersonA und PersonB.

PersonA := {"", "Obama", 6}
PersonB := {"President", "Carter", 8}

Ich möchte eine Funktion schreiben, die Kopien der Werte von PersonA zu PersonB gegeben eine Bedingung für jedes Feld ein (d.h. nicht leer). Ich weiß, wie Sie dies tun, indem die hartcodierung des Feldes Namen, aber ich will eine Funktion, die funktioniert auch wenn ich die Person struct.

Ich weiß, Gehen überlegungen ist hilfreich, aber das Problem ist das abrufen und festlegen der Werte erfordert die Kenntnis der Arten, wenn Sie wollen, etwas zu verwenden, wie SetInt. Aber es ist eine "einfache" Möglichkeit, dies zu tun?

** Javascript-Analogie **
In Javascript können Sie einfach ein (für Immobilien in someObject) zu Durchlaufen.

(for propt in personA) {
  if personA[propt] != "" {
    //do something
    personB[propt] = personA[propt]
  }
}

Optionen, die ich habe ausgeschlossen:

Verfolgen Sie die Felder in den einzelnen struct in eine Karte, dann eine Kombination von FieldByName und die Sammlung von Set* - Funktionen in der reflektieren pkg.
Erstellen einer Schleife durch die Felder von Person manuell (unten). Weil ich will, zu tun, diese Art von "update" für viele andere Strukturen (Schule, Tiere, etc...)
```
if PersonA.Firstname != "" {
  PersonB.Firstname = PersonA.Firstname 
}
```
...
```
if PersonA.Years != "" {
  PersonB.Years = PersonA.Years 
}
```

Die Frage bringt mich auf halbem Weg dorthin, aber noch ist nicht erweiterbar, um alle Strukturen, für die will ich nutzen dieses "update" Funktion.

in golang, mit reflektieren, wie Sie den Wert eines struct-Feld?

** Weitere Nützliche Links **
GoLang: Zugriff auf struct-Eigenschaft nach Namen

InformationsquelleAutor platwp | 2014-04-28

go reflection

Verwenden reflect.ValueOf() zu konvertieren, um den konkreten Typ. Danach könnten Sie reflektieren.Wert.SetString, um den Wert, den Sie wollen.

structValue := FooBar{Foo: "foo", Bar: 10}
fields := reflect.TypeOf(structValue)
values := reflect.ValueOf(structValue)

num := fields.NumField()

for i := 0; i < num; i++ {
    field := fields.Field(i)
    value := values.Field(i)
    fmt.Print("Type:", field.Type, ",", field.Name, "=", value, "\n")

    switch value.Kind() {
    case reflect.String:
        v := value.String())
        fmt.Print(v, "\n")
    case reflect.Int:
        v := strconv.FormatInt(value.Int(), 10)
        fmt.Print(v, "\n")
    case reflect.Int32:
        v := strconv.FormatInt(value.Int(), 10)
        fmt.Print(v, "\n")
    case reflect.Int64:
        v := strconv.FormatInt(value.Int(), 10)
        fmt.Print(v, "\n")
    default:
        assert.Fail(t, "Not support type of struct")
    }
}

InformationsquelleAutor jtianling

Hier ist die Lösung f2.Set(reflect.Value(f)) ist hier der Schlüssel

package main

   import (
    "fmt"
    "reflect"
   )

   func main() {
    type T struct {
        A int
        B string
    }
    t := T{23, "skidoo"}
    t2:= T{}
    s := reflect.ValueOf(&t).Elem()
    s2 := reflect.ValueOf(&t2).Elem()
    typeOfT := s.Type()
    fmt.Println("t=",t)
    fmt.Println("t2=",t2)

    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        f2:= s2.Field(i)
        fmt.Printf("%d: %s %s = %v\n", i,
            typeOfT.Field(i).Name, f.Type(), f.Interface())
        fmt.Printf("%d: %s %s = %v\n", i,
            typeOfT.Field(i).Name, f2.Type(), f2.Interface())
        f2.Set(reflect.Value(f))
        fmt.Printf("%d: %s %s = %v\n", i,
            typeOfT.Field(i).Name, f2.Type(), f2.Interface())

    }
    fmt.Println("t=",t)
    fmt.Println("t2=",t2)
}

Output:

t= {23 skidoo}
t2= {0 }
0: A int = 23
0: A int = 0
0: A int = 23
1: B string = skidoo
1: B string = 
1: B string = skidoo
t= {23 skidoo}
t2= {23 skidoo}

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

InformationsquelleAutor archie

2

Reflexion sollte alles, was Sie brauchen. Dies scheint ähnlich (aber nicht identisch) "Tiefe Kopie" - Semantik, die umgesetzt wurde, bei https://godoc.org/github.com/getlantern/deepcopy

Sollten Sie angepasst werden können, die zu Ihren Bedürfnissen, oder zumindest einige Ideen von ihm.
- Es ist eine riesige Kosten, in der performance und die Komplexität des Codes, um mit Hilfe von Reflexion. @platwp, lohnt sich die Buchung einer übergeordneten Frage, was Sie versuchen zu bauen, wenn dieser kommt. Wenn JavaScript-ish Flexibilität ist wichtig, möchten Sie vielleicht sogar mit dynamischen Sammlungen (map[string]interface{} oder was auch immer) statt der Objekt-Typen.
- Ich hatte gehofft, zu vermeiden, die "Komplexität" Teil. Wenn es keinen "einfachen" Weg, es zu tun, dann dynamische Sammlungen sinnvoll. Danke!
InformationsquelleAutor Evan

Sollten Sie eine map[string]interface{} stattdessen wird viel schneller (obwohl noch nicht so schnell, wie Sie die richtige Logik mit den tatsächlichen Strukturen).

package main

import "fmt"

type Object map[string]interface{}

var m = Object{
    "Firstname": "name",
    "Lastname":  "",
    "years":     uint8(10),
}

func main() {
    var cp = Object{}
    for k, v := range m {
        if s, ok := v.(string); ok && s != "" {
            cp[k] = s
        } else if ui, ok := v.(uint8); ok {
            cp[k] = ui
        }
    }
    fmt.Printf("%#v\n", cp)
}

InformationsquelleAutor OneOfOne

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.