Was nützt die Golang-Reflexion? Der folgende Artikel führt Sie in die Golang-Reflexion ein. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.
golang (go) ist eine prozedurale Programmiersprache, die für die schnelle Kompilierung von Maschinencode verwendet werden kann. Es handelt sich um eine statisch typisierte kompilierte Sprache. Es bietet einen Parallelitätsmechanismus, der die Entwicklung von Multicore- und Netzwerkprogrammen auf Maschinenebene erleichtert. Es handelt sich um eine schnelle, dynamisch typisierte und interpretierte Sprache; sie bietet Unterstützung für Schnittstellen und Typeinbettung.
Grundlegendes Verständnis
In der Go-Sprache ist der Wert/Typ/Funktion meist sehr einfach, wenn Sie möchten, definieren Sie einen . Sie wollen eine Struktur
type Foo struct {
A int
B string
}Sie wollen einen Wert, Sie definieren ihn
var x Foo
Sie wollen eine Funktion, Sie definieren sie
func DoSomething(f Foo) {
fmt.Println(f.A, f.B)
}Aber manchmal müssen Sie etwas tun, das es kann kann nur zur Laufzeit ermittelt werden, z. B. beim Abrufen einiger Wörterbuchdaten aus einer Datei oder dem Netzwerk. Oder vielleicht möchten Sie verschiedene Arten von Daten erhalten. In diesem Fall ist reflection（反射） praktisch. Reflection ermöglicht Ihnen die folgenden Funktionen:
Typ zur Laufzeit prüfen
Zur Laufzeit prüfen/ändern/erstellen Werte/Funktionen/Strukturen
Im Allgemeinen dreht sich gos reflection um drei Konzepte Types, Kinds, Values. Alle Operationen zur Reflexion sind im reflectPaket
Reflection Power
Type Power
<🎜 enthalten >Schauen wir uns zunächst an, wie man den Werttyp durch Reflektion erhält.varType := reflect.TypeOf(var)
package main
import (
"fmt"
"reflect"
)
type FooIF interface {
DoSomething()
DoSomethingWithArg(a string)
DoSomethingWithUnCertenArg(a ... string)
}
type Foo struct {
A int
B string
C struct {
C1 int
}
}
func (f *Foo) DoSomething() {
fmt.Println(f.A, f.B)
}
func (f *Foo) DoSomethingWithArg(a string) {
fmt.Println(f.A, f.B, a)
}
func (f *Foo) DoSomethingWithUnCertenArg(a ... string) {
fmt.Println(f.A, f.B, a[0])
}
func (f *Foo) returnOneResult() int {
return 2
}
func main() {
var simpleObj Foo
var pointer2obj = &simpleObj
var simpleIntArray = [3]int{1, 2, 3}
var simpleMap = map[string]string{
"a": "b",
}
var simpleChan = make(chan int, 1)
var x uint64
var y uint32
varType := reflect.TypeOf(simpleObj)
varPointerType := reflect.TypeOf(pointer2obj)
// 对齐之后要多少容量
fmt.Println("Align: ", varType.Align())
// 作为结构体的`field`要对其之后要多少容量
fmt.Println("FieldAlign: ", varType.FieldAlign())
// 叫啥
fmt.Println("Name: ", varType.Name())
// 绝对引入路径
fmt.Println("PkgPath: ", varType.PkgPath())
// 实际上用了多少内存
fmt.Println("Size: ", varType.Size())
// 到底啥类型的
fmt.Println("Kind: ", varType.Kind())
// 有多少函数
fmt.Println("NumMethod: ", varPointerType.NumMethod())
// 通过名字获取一个函数
m, success := varPointerType.MethodByName("DoSomethingWithArg")
if success {
m.Func.Call([]reflect.Value{
reflect.ValueOf(pointer2obj),
reflect.ValueOf("sad"),
})
}
// 通过索引获取函数
m = varPointerType.Method(1)
m.Func.Call([]reflect.Value{
reflect.ValueOf(pointer2obj),
reflect.ValueOf("sad2"),
})
// 是否实现了某个接口
fmt.Println("Implements:", varPointerType.Implements(reflect.TypeOf((*FooIF)(nil)).Elem()))
// 看看指针多少bit
fmt.Println("Bits: ", reflect.TypeOf(x).Bits())
// 查看array, chan, map, ptr, slice的元素类型
fmt.Println("Elem: ", reflect.TypeOf(simpleIntArray).Elem().Kind())
// 查看Array长度
fmt.Println("Len: ", reflect.TypeOf(simpleIntArray).Len())
// 查看结构体field
fmt.Println("Field", varType.Field(1))
// 查看结构体field
fmt.Println("FieldByIndex", varType.FieldByIndex([]int{2, 0}))
// 查看结构提field
fi, success2 := varType.FieldByName("A")
if success2 {
fmt.Println("FieldByName", fi)
}
// 查看结构体field
fi, success2 = varType.FieldByNameFunc(func(fieldName string) bool {
return fieldName == "A"
})
if success2 {
fmt.Println("FieldByName", fi)
}
// 查看结构体数量
fmt.Println("NumField", varType.NumField())
// 查看map的key类型
fmt.Println("Key: ", reflect.TypeOf(simpleMap).Key().Name())
// 查看函数有多少个参数
fmt.Println("NumIn: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumIn())
// 查看函数参数的类型
fmt.Println("In: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).In(0))
// 查看最后一个参数，是否解构了
fmt.Println("IsVariadic: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).IsVariadic())
// 查看函数有多少输出
fmt.Println("NumOut: ", reflect.TypeOf(pointer2obj.DoSomethingWithUnCertenArg).NumOut())
// 查看函数输出的类型
fmt.Println("Out: ", reflect.TypeOf(pointer2obj.returnOneResult).Out(0))
// 查看通道的方向, 3双向。
fmt.Println("ChanDir: ", int(reflect.TypeOf(simpleChan).ChanDir()))
// 查看该类型是否可以比较。不能比较的slice, map, func
fmt.Println("Comparable: ", varPointerType.Comparable())
// 查看类型是否可以转化成另外一种类型
fmt.Println("ConvertibleTo: ", varPointerType.ConvertibleTo(reflect.TypeOf("a")))
// 该类型的值是否可以另外一个类型
fmt.Println("AssignableTo: ", reflect.TypeOf(x).AssignableTo(reflect.TypeOf(y)))
}Power of Value
Zusätzlich zur Überprüfung des Typs einer Variablen können Sie lesen/schreiben /erstelle einen neuen durch Reflexionswert. Holen Sie sich aber zunächst den ReflexionswerttyprefVal := reflect.ValueOf(var)
refPtrVal := reflect.ValueOf(&var)
refPtrVal.Elem().Set(newRefValue)
newPtrVal := reflect.New(varType)
package main
import (
"fmt"
"reflect"
)
func main() {
// swap is the implementation passed to MakeFunc.
// It must work in terms of reflect.Values so that it is possible
// to write code without knowing beforehand what the types
// will be.
swap := func(in []reflect.Value) []reflect.Value {
return []reflect.Value{in[1], in[0]}
}
// makeSwap expects fptr to be a pointer to a nil function.
// It sets that pointer to a new function created with MakeFunc.
// When the function is invoked, reflect turns the arguments
// into Values, calls swap, and then turns swap's result slice
// into the values returned by the new function.
makeSwap := func(fptr interface{}) {
// fptr is a pointer to a function.
// Obtain the function value itself (likely nil) as a reflect.Value
// so that we can query its type and then set the value.
fn := reflect.ValueOf(fptr).Elem()
// Make a function of the right type.
v := reflect.MakeFunc(fn.Type(), swap)
// Assign it to the value fn represents.
fn.Set(v)
}
// Make and call a swap function for ints.
var intSwap func(int, int) (int, int)
makeSwap(&intSwap)
fmt.Println(intSwap(0, 1))
// Make and call a swap function for float64s.
var floatSwap func(float64, float64) (float64, float64)
makeSwap(&floatSwap)
fmt.Println(floatSwap(2.72, 3.14))
}Typ und Schnittstelle verstehen
Los ist eine statisch typisierte Sprache, z. B. int, float. Was ist ein statischer Typ? Beispielsweise bedeutet derselbe Binärblock 00000001 im Typ „bool“ wahr. Die Erklärung im int-Typ ist 1. Schauen wir uns das folgende einfachste Beispiel an:
type MyInt int var i int var j MyInt
package main
import (
"fmt"
)
type A interface {
x(param int)
}
type B interface {
y(param int)
}
type AB struct {
}
func (ab *AB) x(param int) {
fmt.Printf("%p", ab)
fmt.Println(param)
}
func (ab *AB) y(param int) {
fmt.Printf("%p", ab)
fmt.Println(param)
}
func printX(a A){
fmt.Printf("%p", a)
a.x(2)
}
func printY(b B){
fmt.Printf("%p", b)
b.y(3)
}
func main() {
var ab = new(AB)
printX(ab)
printY(ab)
var aInfImpl A
var bInfImpl B
aInfImpl = new(AB)
//bInfImpl = aInfImpl 会报错
bInfImpl = aInfImpl.(B)
bInfImpl.y(2)
}Teilen Sie einen Schnittstellenwert in ein Reflexionsobjekt auf
Die Reflexion wird nur zur Überprüfung des Schnittstellenwerts (Wert, Typ) verwendet. Wie im vorherigen Kapitel erwähnt, sind die beiden Methoden ValueOf und TypeOf. Über ValueOf können wir Type
package main
import (
"fmt"
"reflect"
)
func main() {
var x float64 = 3.4
fmt.Println("type:", reflect.TypeOf(x))
}type: float64
func TypeOf(i interface{}) TypeKombinieren Sie das Reflexionsobjekt zu einem Schnittstellenwert
就像镜面反射一样，go的反射是可逆的。给我一个reflect.Value。我们能够恢复出一个interface的值。事实上，以下函数干的事情就是将Value和Type组狠起来塞到 interface里面去。所以我们可以
y := v.Interface().(float64) // y will have type float64. fmt.Println(y)
接下来就是见证奇迹的时刻。fmt.Println和fmt.Printf的参数都是interface{}。我们真正都不需要将上面例子的y转化成明确的float64。我就可以去打印他比如
fmt.Println(v.Interface())
甚至我们的interface藏着的那个type是float64。我们可以直接用占位符来打印
fmt.Println("Value is %7.le\n", v.Interface())再重复一边，没有必要将v.Interface()的类型强转到float64;这个空的interface{}包含了concrete type。函数调用会恢复出来
要改变一个反射对象，其值必须是可设置的
第三条比较让你比较困惑。不过如果我们理解了第一条，那么这条其实非常好理解。先看一下下面这个例子
var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1) // Error: will panic.
如果执行这段代码，你会发现出现panic以下信息
panic: reflect.Value.SetFloat using unaddressable value
可设置性是一个好东西，但不是所有reflect.Value都有他...可以通过CanSet 函数来获取是否可设置
var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("settability of v:", v.CanSet())那么到底为什么要有一个可设置性呢？可寻址才可设置，我们在用reflect.ValueOf时候，实际上是函数传值。获取x的反射对象，实际上是另外一个float64的内存的反射对象。这个时候我们再去设置该反射对象的值，没有意义。这段内存并不是你申明的那个x。
推荐学习：Golang教程
Das obige ist der detaillierte Inhalt vonWas nützt die Golang-Reflexion?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So definieren Sie Variablen in Golang
Welche Datenkonvertierungsmethoden gibt es in Golang?
Was sind die aufrufenden Methoden der Java-Reflexion?
Welche sind die am häufigsten verwendeten Bibliotheken in Golang?
Was ist der Unterschied zwischen Golang und Python?
Was tun, wenn die CHM-Datei nicht geöffnet werden kann?
So registrieren Sie ein Bitcoin-Wallet
Der Unterschied zwischen CSS3.0 und CSS2.0
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
