Que sont CanSet, CanAddr ?

                                                     

Ce qui suit est

Tutoriel Golang La chronique présentera ce qu'est le corset, canaddr, j'espère que cela sera utile aux amis qui en ont besoin !

Un article pour comprendre ce qu'est CanSet, CanAddr ?

Qu'est-ce que CanSet

Tout d'abord, nous devons clarifier que CanSet est pour Reflect.Value. Pour convertir une variable ordinaire en reflet.Value, vous devez d'abord utiliser réfléchissant.ValueOf() pour la convertir.

Alors pourquoi existe-t-il une méthode aussi « réglable » ? Par exemple, l'exemple suivant :

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

Tous les appels de fonction dans golang sont des copies de valeur, donc lors de l'appel de reflex.ValueOf, un x ​​a été copié et passé, et le v obtenu ici est un x. valeur de la copie. Donc, pour le moment, nous voulons savoir si je peux définir la variable x ici via v. Nous avons besoin d'une méthode pour nous aider à le faire : CanSet()

Cependant, il est très évident que puisque nous transmettons une copie de x, la valeur de x ne peut pas être modifiée du tout. Ce qui est montré ici est faux.

Et si on y passait l'adresse de x ? Voici un exemple :

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

Nous transmettons l'adresse de la variable x à réflexion.ValueOf. Ce devrait être CanSet. Mais une chose à noter ici est que v pointe ici vers le pointeur de x. Ainsi, la méthode CanSet détermine si le pointeur de x peut être défini. Les pointeurs ne peuvent certainement pas être définis, donc false est toujours renvoyé ici.

Ensuite, ce que nous devons juger à partir de la valeur de ce pointeur, c'est si l'élément pointé par ce pointeur peut être défini. Heureusement, Reflect fournit la méthode Elem() pour obtenir "l'élément pointé par le pointeur". .

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

renvoie enfin vrai. Mais il y a une condition préalable lors de l'utilisation d'Elem(). La valeur ici doit être réfléchie.Valeur convertie à partir d'un objet pointeur. (Ou Reflect.Value pour la conversion d'objet d'interface). Cette prémisse n'est pas difficile à comprendre. S'il s'agit d'un type int, comment peut-il avoir un élément vers lequel il pointe ? Soyez donc très prudent lorsque vous utilisez Elem, car si cette condition n’est pas remplie, Elem déclenchera directement une panique.

Après avoir jugé s'il peut être défini, nous pouvons effectuer les réglages correspondants via la série de méthodes SetXX.

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

Types plus complexes

Pour les tranches, cartes, structures, pointeurs et autres méthodes complexes, j'ai écrit un exemple :

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

Si vous pouvez comprendre les exemples ci-dessus, alors vous comprenez essentiellement la méthode CanSet.

Une attention particulière doit être portée au fait que la carte et le pointeur n'ont pas besoin de transmettre des pointeurs pour refléter.ValueOf lorsqu'ils sont modifiés. Parce qu’ils sont eux-mêmes des indicateurs.

Ainsi, lorsque nous appelons Reflect.ValueOf, nous devons être très clairs sur la structure sous-jacente de la variable que nous voulons transmettre. Par exemple, map transfère en fait un pointeur, et nous n'avons plus besoin de le pointer. Quant à slice, ce qui est réellement passé est une structure SliceHeader. Lorsque nous modifions Slice, nous devons passer le pointeur de SliceHeader. C’est quelque chose auquel nous devons souvent prêter attention.

CanAddr

Comme vous pouvez le voir dans le package Reflect, en plus de CanSet, il existe également une méthode CanAddr. Quelle est la différence entre les deux ?

La différence entre la méthode CanAddr et la méthode CanSet est que pour certains champs privés de la structure, nous pouvons obtenir son adresse, mais nous ne pouvons pas la définir.

Par exemple, l'exemple suivant :

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

Donc, CanAddr est une condition nécessaire et insuffisante de CanSet. Une valeur si CanAddr, pas nécessairement CanSet. Mais si une variable canSet, elle doit être CanAddr.

Code source

Supposons que nous souhaitions implémenter cet élément de valeur CanSet ou CanAddr, nous utiliserons très probablement la marque de bit de drapeau. C'est effectivement le cas.

Regardons d'abord la structure de Value :

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

Ce qu'il convient de noter ici, c'est qu'il s'agit d'une structure imbriquée avec un drapeau imbriqué à l'intérieur, et le drapeau lui-même est un uintptr.

type flag uintptr

Ce drapeau est très important. Il peut exprimer non seulement le type de la valeur, mais aussi certaines méta-informations (comme si elle est adressable, etc.). Bien que flag soit de type uint, il est représenté par des bits.

Il doit d'abord représenter le type. Il existe 27 types en 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 就能完全理解了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!