Verwenden Sie reflect.typeof () und reflect.Valueof (), um den Typ und den Wert der Variablen zu erhalten, wobei ValueOF eine Kopie zurückgibt. 2. Sie k?nnen die Strukturfelder durch Reflexion durchqueren, um den Feldnamen, die Typ- und Beschriftungsinformationen zu erhalten. 3. Um den Wert zu ?ndern, müssen Sie einen Zeiger übergeben und Elem () anrufen, um den adressierbaren Wert zu erhalten, und Sie müssen Canset () überprüfen. 4.. Sie k?nnen die Strukturfelder durchqueren und einen neuen Wert entsprechend dem Typ festlegen. 5. Holen Sie sich die Methode über methodByName () und rufen Sie sie mit call () an; 6. Sie k?nnen bestimmen, ob der Typ eine bestimmte Methode oder Schnittstelle implementiert. Die Reflexionsleistung ist niedrig, daher sollten Sie es vermeiden, einen hei?en Pfad zu verwenden. Wenn Sie den Wert ?ndern, müssen Sie einen Zeiger übergeben. Das nicht exportierte Feld kann nicht ge?ndert werden. Das Typ -Urteil wird bevorzugt, ob sort () verwendet wird. Dieser Mechanismus ist bei JSON -Serialisierung, ORM- und Konfigurationsanalyse sehr praktisch.

In Go ist Reflection ein leistungsstarker Mechanismus, mit dem Programme die Typen und Werte von Variablen zur Laufzeit überprüfen und sogar ?ndern k?nnen. Das reflect -Paket von GO bietet die Hauptfunktionen, um die Reflexion zu implementieren. Hier sind einige h?ufige Beispiele, um zu veranschaulichen, wie die Reflexion von GO verwendet wird.

1. Reflexion grundlegender Typen und Werte

Verwenden Sie reflect.TypeOf() und reflect.ValueOf() um den Typ und den Wert einer Variablen zu erhalten.

 Paket Main

importieren (
    "fmt"
    "reflektieren"
)

func main () {
    var x int = 42

    t: = reflect.typeof (x) // Informationen v: = reflektiert
    fmt.println ("Wert:", v) // 42
    fmt.println ("Art:", v.kind ()) // int
}

HINWEIS: reflect.ValueOf(x) Gibt eine Kopie von x zurück, keine Referenz.

2. Erhalten Sie die Feldinformationen der Struktur

Reflexion wird h?ufig verwendet, um Strukturen zu verarbeiten, z. B. Feldnamen, Typen, Beschriftungen usw.

 Geben Sie die Benutzerstruktur {ein
    Name Zeichenfolge `JSON:" Name "`
    Alter int `JSON:" Alter "`
}

func main () {
    var u Benutzer
    t: = reflect.typeof (u)

    für i: = 0; i <t.numfield (); ich {
        Feld: = T.Field (i)
        fmt.printf ("Feldname: %s, Typ: %s, json Tag: %s \ n",
            field.name, field.type, field.tag.get ("json"))
    }
}

Ausgabe:

 Feldname: Name, Typ: String, JSON -Tag: Name
Feldname: Alter, Typ: Int, JSON Tag: Alter

3.. ?ndern Sie den Wert der Variablen (müssen den Zeiger übergeben).

Wenn Sie den Wert durch Reflexion ?ndern m?chten, müssen Sie einen Zeiger übergeben, andernfalls ist es Panik.

 func main () {
    var x int = 10
    v: = reflect.Valueof (& x) // pass in Zeiger Elem: = v.elem () // den Wert, auf den der Zeiger if Elem.canset () {) vermittelt wird
        Elem.Setint (20)
    }

    fmt.println (x) // Ausgabe: 20
}

elem.CanSet() bestimmt, ob der Wert ge?ndert werden kann (z. B. nicht exportierte Felder k?nnen nicht festgelegt werden).

4. Durchqueren und Festlegen von Strukturfeldern

 Typ Person struct {
    Name Zeichenfolge
    Alter int
}

func main () {
    P: = Person {Name: "Alice", Alter: 0}
    v: = reflect.Valueof (& p) .elem () // den modifizierbaren Wert erhalten, auf den der Zeiger für i: = 0 zeigt; i <v.numfield (); ich {
        Feld: = v.field (i)
        if field.canset () && field.kind () == reflect.int {
            Field.Setint (25)
        }
    }

    fmt.printf ("% v \ n", p) // {Name: Alice Age: 25}
}

5. Aufrufmethode (nach Reflexion)

 Geben Sie die Begrü?ungsstruktur {} ein

Func (G Begrü?er) Sayhello (Name String) {
    fmt.println ("Hallo,", Name)
}

func main () {
    G: = Begrü?er {}
    v: = reflektiert.Valueof (g)

    // Methodenmethode abrufen: = V.MethodbyName ("Sayhello")
    if methode.isvalid () {
        args: = [] reflektiert.Value {reflect.Valueof ("bob")}
        method.call (args) // Ausgabe: Hallo, Bob
    }
}

6. Bestimmen Sie, ob der Typ eine Schnittstelle implementiert

 Typlautsprecherschnittstelle {
    Speak () String
}

Geben Sie Hundestruktur {} ein

func (d hund) speak () string {return "woof!" }

func main () {
    D: = Hund {}
    t: = reflect.typeof (d)
    _, OK: = T.MethodbyName ("Speak")
    fmt.println ("implementiert die Sprechmethode:", OK) // True

    // oder genauer bestimmen, ob die Schnittstelle implementiert ist.
    fmt.println ("Schnittstelle definiert sprechen:", implementiert)
}

Zusammenfassung: Gemeinsame Operationen zur Reflexion

• reflect.TypeOf(v) → Typ abrufen
• reflect.ValueOf(v) → den Wert abrufen
• .Kind() → Grundtypen (wie int , struct , slice usw.)
• .Elem() → Zeiger, Schnittstelle zugrunde liegender Wert
• .Field(i) / .Method(i) → Feld oder Methode Holen Sie sich
• .SetXXX() → den Wert ?ndern (erfordert adressierbar)
• .Call() → Aufrufmethode

Dinge zu beachten

• Die Reflexionsleistung ist gering. Versuchen Sie also, sie im hei?en Pfad zu verwenden.
• Beim ?ndern von Werten mit Reflexion muss ein Zeiger übergeben werden, andernfalls kann er nicht ge?ndert werden.
• Beachten Sie, ob das Feld exportiert werden kann (erster Buchstabe), andernfalls ist CanSet() falsch.
• Verwenden Sie Kind() anstelle von Type() um Typ mehr zu beurteilen, da Kind den zugrunde liegenden Typ zurückgibt.

Grunds?tzlich diese gemeinsamen Verwendungen. Obwohl die Reflexion von Go wie in anderen Sprachen nicht so flexibel ist, ist es in Szenarien wie Serialisierung (wie JSON), ORM, Konfigurationsanalyse usw. sehr praktisch, etc.

Das obige ist der detaillierte Inhalt vonGehen Sie mit Beispielreflexion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!