CanSet, CanAddr이란 무엇입니까?

                                                        O l lGolang 튜토리얼

이 섹션에서는 CANSET, Canaddr이 무엇인지 소개하겠습니다. 도움이 필요한 친구들에게 도움이 되길 바랍니다!

CanSet, CanAddr이 무엇인지 이해하기 위한 글인가요?

CanSet이란 무엇입니까

우선 CanSet이 Reflect.Value를 위한 것임을 명확히 해야 합니다. 일반 변수를 Reflect.Value로 변환하려면 먼저 Reflect.ValueOf()를 사용하여 변환해야 합니다. 그러면 왜 그런 "설정 가능한" 방법이 있는 걸까요? 예를 들어 다음 예시는

var x float64 = 3.4v := reflect.ValueOf(x)fmt.Println(v.CanSet()) // false

golang의 모든 함수 호출은 값 복사이므로, Reflect.ValueOf 호출 시 x가 복사되어 전달되었습니다. 여기서 얻은 v는 x의 복사본 값입니다. . 그래서 이번에는 v를 통해 여기서 x 변수를 설정할 수 있는지 알고 싶습니다. 이를 수행하는 데 도움이 되는 메서드가 필요합니다: CanSet()

그러나 x의 복사본을 전달하므로 여기에서 x의 값을 전혀 변경할 수 없다는 것이 매우 분명합니다. 여기에 표시된 내용은 거짓입니다.

그럼 x의 주소를 전달하면 어떻게 될까요? 예는 다음과 같습니다.

var x float64 = 3.4v := reflect.ValueOf(&x)fmt.Println(v.CanSet()) // false

reflect.ValueOf에 x 변수의 주소를 전달합니다. CanSet이어야 합니다. 그러나 여기서 주목해야 할 점은 v가 x의 포인터를 가리킨다는 것입니다. 따라서 CanSet 메서드는 x 포인터를 설정할 수 있는지 여부를 결정합니다. 포인터는 확실히 설정할 수 없으므로 여기서는 여전히 false가 반환됩니다.

그러면 이 포인터의 값으로 판단해야 할 것은 이 포인터가 가리키는 요소를 설정할 수 있는지 여부입니다. 다행히도 Reflect에서는 "포인터가 가리키는 요소"를 얻기 위한 Elem() 메서드를 제공합니다.

var x float64 = 3.4v := reflect.ValueOf(&x)fmt.Println(v.Elem().CanSet()) // true

드디어 true를 반환합니다. 하지만 Elem()을 사용하려면 전제조건이 있습니다. 여기서 값은 포인터 객체에서 변환된 Reflect.Value여야 합니다. (또는 인터페이스 객체 변환을 위한 Reflect.Value). 이 전제는 이해하기 어렵지 않습니다. int 유형이라면 그것이 가리키는 요소를 어떻게 가질 수 있습니까? 따라서 Elem을 사용할 때는 이에 대해 매우 주의해야 합니다. 왜냐하면 이 전제 조건이 충족되지 않으면 Elem이 직접적으로 패닉을 유발하기 때문입니다.

설정 가능 여부를 판단한 후 SetXX 시리즈 방법을 통해 해당 설정을 할 수 있습니다.

var x float64 = 3.4v := reflect.ValueOf(&x)if v.Elem().CanSet() {
    v.Elem().SetFloat(7.1)}fmt.Println(x)

더 복잡한 유형

복잡한 슬라이스, 맵, 구조체, 포인터 및 기타 메서드에 대해 다음 예제를 작성했습니다.

package mainimport (
    "fmt"
    "reflect")type Foo interface {
    Name() string}type FooStruct struct {
    A string}func (f FooStruct) Name() string {
    return f.A}type FooPointer struct {
    A string}func (f *FooPointer) Name() string {
    return f.A}func main() {
    {
        // slice
        a := []int{1, 2, 3}
        val := reflect.ValueOf(&a)
        val.Elem().SetLen(2)
        val.Elem().Index(0).SetInt(4)
        fmt.Println(a) // [4,2]
    }
    {
        // map
        a := map[int]string{
            1: "foo1",
            2: "foo2",
        }
        val := reflect.ValueOf(&a)
        key3 := reflect.ValueOf(3)
        val3 := reflect.ValueOf("foo3")
        val.Elem().SetMapIndex(key3, val3)
        fmt.Println(val) // &map[1:foo1 2:foo2 3:foo3]
    }
    {
        // map
        a := map[int]string{
            1: "foo1",
            2: "foo2",
        }
        val := reflect.ValueOf(a)
        key3 := reflect.ValueOf(3)
        val3 := reflect.ValueOf("foo3")
        val.SetMapIndex(key3, val3)
        fmt.Println(val) // &map[1:foo1 2:foo2 3:foo3]
    }
    {
        // struct
        a := FooStruct{}
        val := reflect.ValueOf(&a)
        val.Elem().FieldByName("A").SetString("foo2")
        fmt.Println(a) // {foo2}
    }
    {
        // pointer
        a := &FooPointer{}
        val := reflect.ValueOf(a)
        val.Elem().FieldByName("A").SetString("foo2")
        fmt.Println(a) //&{foo2}
    }}

위 예제를 이해할 수 있다면 기본적으로 CanSet 메서드를 이해한 것입니다.

특히, 맵과 포인터가 수정될 때 반영하기 위해 포인터를 전달할 필요가 없다는 사실에 주목할 수 있습니다. 포인터 자체이기 때문입니다.

따라서 Reflect.ValueOf를 호출할 때 전달하려는 변수의 기본 구조에 대해 매우 명확해야 합니다. 예를 들어, 지도는 실제로 포인터를 전송하므로 더 이상 포인터를 가리킬 필요가 없습니다. 슬라이스의 경우 실제로 전달되는 것은 SliceHeader 구조입니다. Slice를 수정할 때 SliceHeader의 포인터를 전달해야 합니다. 이것은 우리가 종종 주의를 기울여야 할 사항입니다.

CanAddr

Reflect 패키지를 보면 CanSet 외에 CanAddr 메소드도 있다는 것을 알 수 있습니다. 둘 사이의 차이점은 무엇입니까? CanAddr 메서드와 CanSet 메서드의 차이점은 구조의 일부 비공개 필드의 경우 주소를 얻을 수 있지만 설정할 수는 없다는 것입니다.

예를 들어 다음 예는

package mainimport (
    "fmt"
    "reflect")type FooStruct struct {
    A string
    b int}func main() {
    {
        // struct
        a := FooStruct{}
        val := reflect.ValueOf(&a)
        fmt.Println(val.Elem().FieldByName("b").CanSet())  // false
        fmt.Println(val.Elem().FieldByName("b").CanAddr()) // true
    }}

그래서 CanAddr은 CanSet의 필요조건이자 불충분조건입니다. CanAddr인 경우 값(CanSet일 필요는 없음) 그러나 변수가 canSet인 경우에는 CanAddr이어야 합니다.

소스 코드

이 값 요소 CanSet 또는 CanAddr을 구현한다고 가정하면 마크 비트 표시를 사용할 가능성이 높습니다. 실제로 그렇습니다. 먼저 Value의 구조를 살펴보겠습니다.

type Value struct {
    typ *rtype
    ptr unsafe.Pointer
    flag}

여기서 주목해야 할 점은 내부에 플래그가 중첩된 중첩 구조이고 플래그 자체가 uintptr이라는 점입니다.

type flag uintptr

이 플래그는 값의 유형뿐만 아니라 일부 메타 정보(예: 주소 지정 가능 여부 등)도 표현할 수 있습니다. 플래그는 단위형이지만 비트마크로 표현됩니다.

우선, golang에는 27가지 유형이 있습니다.

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer)

所以使用5位（2^5-1=63）就足够放这么多类型了。所以 flag 的低5位是结构类型。

第六位 flagStickyRO: 标记是否是结构体内部私有属性
第七位 flagEmbedR0: 标记是否是嵌套结构体内部私有属性
第八位 flagIndir: 标记 value 的ptr是否是保存了一个指针
第九位 flagAddr: 标记这个 value 是否可寻址
第十位 flagMethod: 标记 value 是个匿名函数

其中比较不好理解的就是 flagStickyRO,flagEmbedR0

看下面这个例子：

type FooStruct struct {
    A string
    b int}type BarStruct struct {
    FooStruct}{
        b := BarStruct{}
        val := reflect.ValueOf(&b)
        c := val.Elem().FieldByName("b")
        fmt.Println(c.CanAddr())}

这个例子中的 c 的 flagEmbedR0 标记位就是1了。

所以我们再回去看 CanSet 和 CanAddr 方法

func (v Value) CanAddr() bool {
    return v.flag&flagAddr != 0}func (v Value) CanSet() bool {
    return v.flag&(flagAddr|flagRO) == flagAddr}

他们的方法就是把 value 的 flag 和 flagAddr 或者 flagRO (flagStickyRO,flagEmbedR0) 做“与”操作。

而他们的区别就是是否判断 flagRO 的两个位。所以他们的不同换句话说就是“判断这个 Value 是否是私有属性”，私有属性是只读的。不能Set。

应用

在开发 collection （https://github.com/jianfengye/collection）库的过程中，我就用到这么一个方法。我希望设计一个方法 func (arr *ObjPointCollection) ToObjs(objs interface{}) error，这个方法能将 ObjPointCollection 中的 objs reflect.Value 设置为参数 objs 中。

func (arr *ObjPointCollection) ToObjs(objs interface{}) error {
    arr.mustNotBeBaseType()

    objVal := reflect.ValueOf(objs)
    if objVal.Elem().CanSet() {
        objVal.Elem().Set(arr.objs)
        return nil    }
    return errors.New("element should be can set")}

使用方法：

func TestObjPointCollection_ToObjs(t *testing.T) {
    a1 := &Foo{A: "a1", B: 1}
    a2 := &Foo{A: "a2", B: 2}
    a3 := &Foo{A: "a3", B: 3}

    bArr := []*Foo{}
    objColl := NewObjPointCollection([]*Foo{a1, a2, a3})
    err := objColl.ToObjs(&bArr)
    if err != nil {
        t.Fatal(err)
    }
    if len(bArr) != 3 {
        t.Fatal("toObjs error len")
    }
    if bArr[1].A != "a2" {
        t.Fatal("toObjs error copy")
    }}

总结

CanAddr 和 CanSet 刚接触的时候是会有一些懵逼，还是需要稍微理解下 reflect.Value 的 flag 就能完全理解了。

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