Obtenir pointeur vers la valeur à l'aide de la réflexion

J'ai une fonction qui parcourt tous les champs d'une interface passé comme paramètre. Afin d'atteindre cet objectif est, je suis l'aide de la réflexion. Le problème est que je ne sais pas comment faire pour obtenir l'adresse d'un non-pointeur de champ. Voici un exemple:

type Z struct {
    Id int
}

type V struct {
    Id int
    F Z
}

type T struct {
    Id int
    F V
}

Le code ci-dessus représente mon test de structures. Maintenant, voici la fonction qui traverse une structure et des listes de détails à ce sujet:

func InspectStruct(o interface{}) {
val := reflect.ValueOf(o)
if val.Kind() == reflect.Interface && !val.IsNil() {
elm := val.Elem()
if elm.Kind() == reflect.Ptr && !elm.IsNil() && elm.Elem().Kind() == reflect.Ptr {
val = elm
}
}
if val.Kind() == reflect.Ptr {
val = val.Elem()
}
for i := 0; i < val.NumField(); i++ {
valueField := val.Field(i)
typeField := val.Type().Field(i)
address := "not-addressable"
if valueField.Kind() == reflect.Interface && !valueField.IsNil() {
elm := valueField.Elem()
if elm.Kind() == reflect.Ptr && !elm.IsNil() && elm.Elem().Kind() == reflect.Ptr {
valueField = elm
}
}
if valueField.Kind() == reflect.Ptr {
valueField = valueField.Elem()
}
if valueField.CanAddr() {
address = fmt.Sprint(valueField.Addr().Pointer())
}
fmt.Printf("Field Name: %s,\t Field Value: %v,\t Address: %v\t, Field type: %v\t, Field kind: %v\n", typeField.Name, 
valueField.Interface(), address, typeField.Type, valueField.Kind())
if valueField.Kind() == reflect.Struct {
InspectStruct(valueField.Interface())
}
}
}

Et voici le test après l'instanciation de la structure/initialisation:

t := new(T)
t.Id = 1
t.F = *new(V)
t.F.Id = 2
t.F.F = *new(Z)
t.F.F.Id = 3
InspectStruct(t)

Et enfin la sortie de InspectStruct appel:

Field Name: Id,  Field Value: 1,     Address: 408125440 , Field type: int   , Field kind: int
Field Name: F,   Field Value: {2 {3}},   Address: 408125444 , Field type: main.V    , Field kind: struct
Field Name: Id,  Field Value: 2,     Address: not-addressable   , Field type: int   , Field kind: int
Field Name: F,   Field Value: {3},   Address: not-addressable   , Field type: main.Z    , Field kind: struct
Field Name: Id,  Field Value: 3,     Address: not-addressable   , Field type: int   , Field kind: int

Comme vous pouvez le voir, je suis en utilisant la récursivité, de sorte que si l'un des champs est un struct type puis-je appeler InspectStruct.
Mon problème est que si tous les champs ont été initialisé pour l'ensemble de la structure en "t" de la hiérarchie, je ne suis pas en mesure d'obtenir l'adresse de tout le terrain situé à plus de profondeur que de "t". Je serais vraiment reconnaissant de toute aide.

OriginalL'auteur Mihai H | 2014-06-22

go reflection

Passant reflect.Value au lieu de interface{} semble résoudre le problème, mais je ne sais pas pourquoi valueField.Interface() ne fonctionne pas.

De travail exemple : http://play.golang.org/p/nleA2YWMj8

func InspectStructV(val reflect.Value) {
if val.Kind() == reflect.Interface && !val.IsNil() {
elm := val.Elem()
if elm.Kind() == reflect.Ptr && !elm.IsNil() && elm.Elem().Kind() == reflect.Ptr {
val = elm
}
}
if val.Kind() == reflect.Ptr {
val = val.Elem()
}
for i := 0; i < val.NumField(); i++ {
valueField := val.Field(i)
typeField := val.Type().Field(i)
address := "not-addressable"
if valueField.Kind() == reflect.Interface && !valueField.IsNil() {
elm := valueField.Elem()
if elm.Kind() == reflect.Ptr && !elm.IsNil() && elm.Elem().Kind() == reflect.Ptr {
valueField = elm
}
}
if valueField.Kind() == reflect.Ptr {
valueField = valueField.Elem()
}
if valueField.CanAddr() {
address = fmt.Sprintf("0x%X", valueField.Addr().Pointer())
}
fmt.Printf("Field Name: %s,\t Field Value: %v,\t Address: %v\t, Field type: %v\t, Field kind: %v\n", typeField.Name,
valueField.Interface(), address, typeField.Type, valueField.Kind())
if valueField.Kind() == reflect.Struct {
InspectStructV(valueField)
}
}
}
func InspectStruct(v interface{}) {
InspectStructV(reflect.ValueOf(v))
}

OriginalL'auteur OneOfOne

11

La raison Interface() ne fonctionne pas est à cause de l'interface wrapper il retourne. Pour donner une idée de ce qui se passe, nous allons regarder ce que nous faisons sans réflexion:
```
type MyStruct struct {
F Foo
}
type Foo struct {
i int
}
func ExtractField(ptr *MyStruct) interface{} {
return ptr.F
}
func main() {
ms := &MyStruct{Foo{5}}
f := ExtractField(ms).(Foo) //extract value
f.i = 19
fmt.Println(f, ms.F)            //???
fmt.Println(&f == &ms.F)        //Not the same!
}
```
(Aire de jeux)

Cependant, penser à la interface{} cela renvoie. Qu'est-ce que c'emballage? Le valeur de ptr.F - copie. C'est ce que value.Interface n', il vous renvoie la interface{} enveloppant le terrain. Il n'y a plus aucun pointeur de métadonnées, il est complètement détaché de l'original struct.

Comme vous l'aurez remarque, le passage d'une valeur directement à reflect.ValueOf retournera toujours false pour CanAddr pour le "top niveau" -- parce que l'adresse est vide de sens, car il vous donnera l'adresse de la copie de la valeur, l'évolution n'était pas vraiment dire quoi que ce soit. (Gardez à l'esprit que les pointeurs sont des valeurs trop -- si vous voulez l'adresse d'un pointeur de champ à valeurs comme *Foo, vous êtes vraiment à la recherche pour **Foo).

Ainsi, dans notre exemple ci-dessus, si nous étions à la naïveté de passer dans reflect.ValueOf(ExtractField(ms)) nous aimerions tirer le ValueOf f, qui non seulement n'ont pas l'adresse que vous souhaitez, il n'est même pas adressable selon réfléchir, car il serait jamais donner une adresse valide autant que réfléchir, c'est la seule adresse qu'il pourrait vous donner l'adresse de la valeur interne de la copie dans le Value struct).

Alors pourquoi passer le Value vers le bas le trou de lapin de travail? Eh bien, la seule vraie manière de le dire est que reflect.Value conserve les métadonnées nécessaires lorsque vous utilisez Elem et Field, tandis que le interface{} ne peut pas. Ainsi, alors que la reflect.Value peut ressembler à:
```
//Disclaimer: not the real structure of a reflect.Value
type Value struct {
fieldAddress uintptr
value        Foo
}
```
Tout ce qu'il peut vous donner est ce
```
//Again, an abstraction of the real interface wrapper 
//just for illustration purposes
type interface{} struct {
value Foo
}
```
J'ai appris de cette expérience, merci pour la réponse détaillée.
Merci pour compléter @OneOfOne réponse. Beaucoup apprécié!

OriginalL'auteur LinearZoetrope
2

Je suis descendu un reflètent trou de lapin aujourd'hui, beaucoup appris de l'étude de ce code et Jsor réponse, je vous remercie. Je suis venu à une conclusion différente si sur votre problème, qui conduit à peut-être plus simple solution:

1) Vous êtes en passant un pointeur vers une struct lorsque vous avez initialement appel de la fonction, mais...

2) Lorsque vous recurse en appelant 'InspectStruct(valueField.Interface())', plutôt que de passer à la structure intégré par pointeur, vous êtes le passage par valeur.

Puisque vous êtes de passage par valeur, allez va créer un temporaire et ne vous laisse pas prendre l'adresse. Au lieu de cela, lorsque vous de manière récursive, appel valueField.Addr().Interface(), qui va passer un pointeur vers les systèmes embarqués struct.
```
    if valueField.Kind() == reflect.Struct {
-     InspectStruct(valueField.Interface())
+     InspectStruct(valueField.Addr().Interface())
}
```
Avec ce changement, j'obtiens le résultat que vous attendez:
```
Field Name: Id,  Field Value: 1,     Address: 842350527552  , Field type: int   , Field kind: int
Field Name: F,   Field Value: {2 {3}},   Address: 842350527560  , Field type: lib.V , Field kind: struct
Field Name: Id,  Field Value: 2,     Address: 842350527560  , Field type: int   , Field kind: int
Field Name: F,   Field Value: {3},   Address: 842350527568  , Field type: lib.Z , Field kind: struct
Field Name: Id,  Field Value: 3,     Address: 842350527568  , Field type: int   , Field kind: int
```
OriginalL'auteur Bill Soudan
1

Réponse de @OneofOne est parfait, mais il est préférable d'ajouter un contrôle supplémentaire
```
if valueField.IsValid() {
fmt.Printf("Field Name: %s, Field Value: %v, Address: %v, Field type: %v, Field kind: %v\n", typeField.Name,
valueField.Interface(), address, typeField.Type, valueField.Kind())
}
```
il est nécessaire car parfois, vous pouvez demander de l'interface à partir d'une valeur nulle struct. Celles qu'il arrive, il va paniquer.

OriginalL'auteur Ihor

Vous devez vous connecter pour publier un commentaire.