Was sind CanSet, CanAddr?

                                                        O l lGolang-Tutorial

In diesem Abschnitt wird CANSET und Canaddr vorgestellt. Ich hoffe, es wird Freunden in Not hilfreich sein!

Ein Artikel, um zu verstehen, was CanSet, CanAddr ist?

Was ist CanSet?

Zunächst müssen wir klarstellen, dass CanSet für Reflect.Value gedacht ist. Um eine gewöhnliche Variable in „reflect.Value“ zu konvertieren, müssen Sie sie zuerst mit „reflect.ValueOf()“ konvertieren. Warum gibt es also eine so „einstellbare“ Methode? Zum Beispiel das folgende Beispiel:

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

Alle Funktionsaufrufe in Golang sind Wertkopien. Beim Aufruf von reflekt.ValueOf wurde also ein x kopiert und übergeben. Das hier erhaltene v ist der Wert einer Kopie von x. . Zu diesem Zeitpunkt möchten wir also wissen, ob ich die x-Variable hier über v festlegen kann. Wir brauchen eine Methode, die uns dabei hilft: CanSet()

Es ist jedoch sehr offensichtlich, dass der Wert von x hier überhaupt nicht geändert werden kann, da wir eine Kopie von x übergeben. Was hier angezeigt wird, ist falsch.

Und was wäre, wenn wir die Adresse von x hineingeben? Hier ist ein Beispiel:

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

Wir übergeben die Adresse der x-Variablen an „reflect.ValueOf“. Es sollte CanSet sein. Hier ist jedoch zu beachten, dass v hier auf den Zeiger von x zeigt. Die CanSet-Methode bestimmt also, ob der Zeiger von x gesetzt werden kann. Zeiger können definitiv nicht gesetzt werden, daher wird hier immer noch false zurückgegeben.

Anhand des Werts dieses Zeigers müssen wir dann beurteilen, ob das Element, auf das dieser Zeiger zeigt, festgelegt werden kann. Glücklicherweise stellt Reflect die Methode Elem () bereit, um das „Element, auf das der Zeiger zeigt“ zu erhalten.

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

kehrt endlich wahr zurück. Bei der Verwendung von Elem() gibt es jedoch eine Voraussetzung. Der Wert muss hier „reflect.Value“ aus einem Zeigerobjekt konvertiert werden. (Oder „reflect.Value“ für die Konvertierung von Schnittstellenobjekten). Diese Prämisse ist nicht schwer zu verstehen. Wenn es sich um einen int-Typ handelt, wie kann er ein Element haben, auf das er verweist? Seien Sie daher bei der Verwendung von Elem sehr vorsichtig, denn wenn diese Voraussetzung nicht erfüllt ist, löst Elem direkt eine Panik aus.

Nachdem wir beurteilt haben, ob es eingestellt werden kann, können wir die entsprechenden Einstellungen über die SetXX-Methodenreihe vornehmen.

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

Komplexere Typen

Für komplexe Slice-, Map-, Struktur-, Zeiger- und andere Methoden habe ich ein Beispiel geschrieben:

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

Wenn Sie das obige Beispiel verstehen können, dann verstehen Sie im Grunde auch die CanSet-Methode.

Insbesondere können Sie darauf achten, dass Karte und Zeiger den Zeiger nicht an reflekt.ValueOf übergeben müssen, wenn sie geändert werden. Weil sie selbst Zeiger sind.

Wenn wir also „reflect.ValueOf“ aufrufen, müssen wir uns über die zugrunde liegende Struktur der Variablen, die wir übergeben möchten, im Klaren sein. Beispielsweise überträgt die Karte tatsächlich einen Zeiger, und wir müssen nicht mehr darauf zeigen. Was Slice betrifft, wird tatsächlich eine SliceHeader-Struktur übergeben. Wenn wir Slice ändern, müssen wir den Zeiger von SliceHeader übergeben. Darauf müssen wir oft achten.

CanAddr

Sie können im Reflect-Paket sehen, dass es neben CanSet auch eine CanAddr-Methode gibt. Was ist der Unterschied zwischen den beiden? Der Unterschied zwischen der CanAddr-Methode und der CanSet-Methode besteht darin, dass wir für einige private Felder in der Struktur die Adresse erhalten, sie aber nicht festlegen können.

Zum Beispiel das folgende Beispiel:

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 ist also eine notwendige und unzureichende Bedingung von CanSet. Ein Wert, wenn CanAddr, nicht unbedingt CanSet. Wenn eine Variable jedoch gesetzt werden kann, muss sie CanAddr sein.

Quellcode

Angenommen, wir möchten dieses Wertelement CanSet oder CanAddr implementieren, werden wir höchstwahrscheinlich die Markierungsbitmarke verwenden. Dies ist tatsächlich der Fall. Werfen wir zunächst einen Blick auf die Struktur von Value:

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

Hier ist zu beachten, dass es sich um eine verschachtelte Struktur mit einem darin verschachtelten Flag handelt und das Flag selbst ein uintptr ist.

type flag uintptr

Dieses Flag ist sehr wichtig. Es kann nicht nur den Typ des Werts ausdrücken, sondern auch einige Metainformationen (z. B. ob er adressierbar ist usw.). Obwohl Flag vom Typ uint ist, wird es durch Bitmarkierungen dargestellt.

Zunächst muss es den Typ darstellen. Es gibt 27 Typen in Golang:

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 就能完全理解了。

Das obige ist der detaillierte Inhalt vonWas sind CanSet, CanAddr?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!