Go
Reflexion
Suche…
Bemerkungen
Die reflect
Dokumente sind eine gute Referenz. In der allgemeinen Computerprogrammierung ist die Reflexion die Fähigkeit eines Programms , die Struktur und das Verhalten von sich zur runtime
.
Basierend auf seinem strengen static type
Typensystem hat Go lang einige Regeln ( Gesetze der Reflexion )
Grundlegende Reflect.Value Usage
import "reflect"
value := reflect.ValueOf(4)
// Interface returns an interface{}-typed value, which can be type-asserted
value.Interface().(int) // 4
// Type gets the reflect.Type, which contains runtime type information about
// this value
value.Type().Name() // int
value.SetInt(5) // panics -- non-pointer/slice/array types are not addressable
x := 4
reflect.ValueOf(&x).Elem().SetInt(5) // works
Structs
import "reflect"
type S struct {
A int
b string
}
func (s *S) String() { return s.b }
s := &S{
A: 5,
b: "example",
}
indirect := reflect.ValueOf(s) // effectively a pointer to an S
value := indirect.Elem() // this is addressable, since we've derefed a pointer
value.FieldByName("A").Interface() // 5
value.Field(2).Interface() // "example"
value.NumMethod() // 0, since String takes a pointer receiver
indirect.NumMethod() // 1
indirect.Method(0).Call([]reflect.Value{}) // "example"
indirect.MethodByName("String").Call([]reflect.Value{}) // "example"
Scheiben
import "reflect"
s := []int{1, 2, 3}
value := reflect.ValueOf(s)
value.Len() // 3
value.Index(0).Interface() // 1
value.Type().Kind() // reflect.Slice
value.Type().Elem().Name() // int
value.Index(1).CanAddr() // true -- slice elements are addressable
value.Index(1).CanSet() // true -- and settable
value.Index(1).Set(5)
typ := reflect.SliceOf(reflect.TypeOf("example"))
newS := reflect.MakeSlice(typ, 0, 10) // an empty []string{} with capacity 10
reflect.Value.Elem ()
import "reflect"
// this is effectively a pointer dereference
x := 5
ptr := reflect.ValueOf(&x)
ptr.Type().Name() // *int
ptr.Type().Kind() // reflect.Ptr
ptr.Interface() // [pointer to x]
ptr.Set(4) // panic
value := ptr.Elem() // this is a deref
value.Type().Name() // int
value.Type().Kind() // reflect.Int
value.Set(4) // this works
value.Interface() // 4
Art des Wertes - Paket "reflektieren"
reflect.TypeOf kann verwendet werden, um den Variablentyp beim Vergleichen zu überprüfen
package main
import (
"fmt"
"reflect"
)
type Data struct {
a int
}
func main() {
s:="hey dude"
fmt.Println(reflect.TypeOf(s))
D := Data{a:5}
fmt.Println(reflect.TypeOf(D))
}
Ausgabe :
Schnur
Hauptinformationen
Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow