golang 반사의 용도는 무엇입니까?

골랭 반사의 용도는 무엇인가요? 다음 글에서는 golang 리플렉션에 대해 소개하겠습니다. 도움이 필요한 친구들이 모두 참고할 수 있기를 바랍니다.

golang(go)은 빠른 기계 코드 컴파일에 사용할 수 있는 절차적 프로그래밍 언어입니다. 정적으로 유형이 지정된 컴파일 언어입니다. 이는 멀티 코어 및 네트워크로 연결된 컴퓨터 수준 프로그램을 쉽게 개발할 수 있는 동시성 메커니즘을 제공합니다. 이는 빠르고 동적으로 유형이 지정되고 해석되는 언어이며 인터페이스 및 유형 임베딩을 지원합니다.

기본 이해

Go 언어에서 대부분의 경우 값/유형/함수는 매우 간단합니다. 원한다면 정의하세요. 구조체를 원하면

type Foo struct {
    A int 
    B string
}

값을 원하면 정의하세요

var x Foo

함수를 원하면 정의하세요

func DoSomething(f Foo) {
  fmt.Println(f.A, f.B)
}

하지만 때로는 런타임에만 결정될 수 있는 작업을 수행해야 하는 경우도 있습니다. 파일이나 네트워크에서 사전 데이터를 가져오고 싶습니다. 아니면 다른 유형의 데이터를 얻고 싶을 수도 있습니다. 이 경우 reflection이 유용합니다. reflection（反射）就有用啦。reflection能够让你拥有以下能力：

• 在运行时检查type

• 在运行时检查/修改/创建 值/函数/结构

总的来说，go的reflection围绕者三个概念Types, Kinds, Values。 所有关于反射的操作都在reflectreflection을 사용하면 다음 기능을 사용할 수 있습니다:

• 런타임에 유형 확인
• 런타임에 확인/수정 / 값/함수/구조 만들기

일반적으로 go의 반영은 세 가지 개념, 즉 유형, 종류 을 중심으로 진행됩니다. , 값. 리플렉션에 대한 모든 연산은 reflect 패키지에 있습니다

Power of Reflection

Power of Type

먼저 리플렉션을 통해 값 유형을 얻는 방법을 살펴보겠습니다.

varType := reflect.TypeOf(var)

리플렉션 인터페이스를 보면 우리가 사용하기를 기다리는 많은 기능이 있다는 것을 알 수 있습니다. 댓글에서 확인하실 수 있습니다. 리플렉션 패키지는 우리가 무엇을 하려는지 알고 있다고 가정합니다. 예를 들어 varType.Elem()은 패닉을 일으킬 것입니다. Elem()에는 Array, Chan, Map, Ptr 또는 Slice에 대해서만 이 메서드가 있기 때문입니다. 자세한 내용은 테스트 코드를 참조하세요. 다음 코드를 실행하면 모든 Reflect 함수의 예를 볼 수 있습니다

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

변수의 유형을 확인하는 것 외에도 리플렉션을 통해 값을 읽고/쓰고/생성할 수 있습니다. 하지만 변수 값을 수정하려면 먼저 반사 값 유형

refVal := reflect.ValueOf(var)

을 가져오세요. 변수를 가리키는 리플렉션 포인터를 얻어야 합니다. 구체적인 이유는 나중에 설명하겠습니다

refPtrVal := reflect.ValueOf(&var)

물론 Reflect.Value도 있고, Type() 메서드를 통해 쉽게 Reflect.Type을 얻을 수 있습니다. 변수의 값을 변경하려면

refPtrVal.Elem().Set(newRefValue)

를 사용하세요. 물론 Set 메소드의 매개변수도 반영되어야 합니다.Value새 값을 생성하려면 다음 코드

newPtrVal := reflect.New(varType)

를 사용한 후 다음을 사용하세요. Elem().Set( )을 사용하여 값을 초기화합니다. 물론 다양한 값에 대한 다양한 방법이 있습니다. 여기에는 쓰지 않겠습니다. 아래의 공식 예에 집중해 봅시다

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))
}

Principle

유형과 인터페이스를 명확하게 인식하세요

go는 정적 유형 언어입니다(예: int, float). 유형? , 내 이해는 해석이 가능한 특정 길이의 이진 블록입니다. 예를 들어, 동일한 바이너리 블록 00000001은 bool 유형에서 true를 의미합니다. int 유형에 대한 설명은 1입니다. 다음의 가장 간단한 예를 살펴보겠습니다.

type MyInt int
var i int
var j MyInt

i,j는 메모리에서 기본 유형 int로 표시되지만 실제 코딩 과정에서는 컴파일 중에 컴파일됩니다. 유형에서는 i 값을 j에 직접 할당할 수 없습니다. 좀 이상하지 않나요? 실행하면 컴파일러에서 MyInt 유형의 값을 int 유형의 값에 할당할 수 없다고 알려줍니다. 이 유형은 클래스도 아니고 Python 유형도 아닙니다.

Interface는 메소드 모음을 나타내는 특수 유형입니다. 인터페이스 값은 해당 값이 인터페이스 메서드를 구현하는 한 특정 값을 저장할 수 있습니다. 인터페이스{}는 때때로 Java의 객체와 유사합니다. 실제로 인터페이스는 실제 값과 값의 특정 유형이라는 두 부분으로 구성됩니다. 이는 다음 코드가 다른 언어와 다른 이유를 설명할 수도 있습니다. 인터페이스의 원리에 대한 자세한 내용은 Go 데이터 구조: 인터페이스를 참조하세요.

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)
}

세 가지 Golang 반사 정리

인터페이스 값을 반사 객체로 분할

Reflection은 인터페이스 값(값, 유형)을 확인하는 데에만 사용됩니다. 이전 장에서 언급했듯이 ValueOf와 TypeOf의 두 가지 메서드가 있습니다. ValueOf를 통해 Type

package main
import (
    "fmt"
    "reflect"
)
func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
}

이 코드 출력

type: float64

을 쉽게 얻을 수 있습니다. 그러면 인터페이스가 어디에 있습니까? float64 변수를 선언하면 됩니다. 인터페이스는 어디에서 오는가? 예, 답은 TypeOf 매개변수에 숨겨져 있습니다🎜

func TypeOf(i interface{}) Type

🎜reflect.TypeOf(x)를 호출하면 x가 먼저 빈 인터페이스에 저장됩니다. 그런 다음 함수 실행 스택에 매개변수로 전달됩니다. ** Reflect.TypeOf는 이 인터페이스 쌍을 풀고 유형 정보를 복구합니다**🎜🎜🎜반사 개체를 인터페이스 값으로 결합🎜🎜

就像镜面反射一样，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教程

위 내용은 golang 반사의 용도는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!