Comment convertir une tranche de carte en tranche de structure avec différentes propriétés

l'éditeur php Xigua vous présentera comment convertir des tranches de mappage en tranches structurelles avec différents attributs. En programmation, nous rencontrons souvent des situations où nous devons convertir une tranche de carte en tranche de structure avec des propriétés différentes. Cette transformation nous aide à mieux organiser et gérer les données. Dans cet article, nous présenterons un moyen simple mais efficace de mettre en œuvre cette transformation, rendant votre code plus efficace et flexible. Nous allons jeter un coup d'oeil!

Contenu de la question

J'utilise une API et je dois lui transmettre un fragment de structure. J'ai une carte, je dois donc la convertir en structure.

package main

import "fmt"

func main() {
    a := []map[string]interface{}{}
    b := make(map[string]interface{})
    c := make(map[string]interface{})
    
    b["prop1"] = "foo"
    b["prop2"] = "bar"
    a = append(a, b)

    c["prop3"] = "baz"
    c["prop4"] = "foobar"
    a = append(a, c)

    fmt.println(a)
}

[map[prop1:foo prop2:bar] map[prop3:baz prop4:foobar]]

Donc, dans cet exemple, j'ai des maps a 的切片，其中包含 b 和 c qui sont des maps de chaînes avec des touches différentes.

Je veux a 转换为一个结构体切片，其中第一个元素是一个以 prop1 和 prop2 作为属性的结构体，第二个元素是一个以 prop3 和 prop4 comme structure de propriétés.

Est-ce possible ?

J'ai regardé https://github.com/mitchellh/mapstruct mais je n'arrive pas à le faire fonctionner pour mon cas d'utilisation. J'ai vu cette réponse : https://stackoverflow.com/a/26746461/3390419

Explication comment utiliser la bibliothèque :

mapstructure.Decode(myData, &result)

Cependant, cela semble supposer que la structure dont result est une instance est prédéfinie, alors que dans mon cas, la structure est dynamique. result 是一个实例的结构是预定义的，而在我的例子中，该结构是动态的。

解决方法

您可以做的是首先单独循环每个映射，使用每个映射的键值对构建相应的 reflect.structfield 值切片。准备好这样的切片后，您可以将其传递给 reflect.structof，它将返回一个表示动态结构类型的 reflect.type 值，然后您可以将其传递给 reflect.new 以创建一个 reflect.value

Solution de contournement

Ce que vous pouvez faire est d'abord de parcourir chaque carte individuellement, en créant la tranche de valeur reflect.structfield correspondante en utilisant les paires clé-valeur de chaque carte. Après avoir préparé une telle tranche, vous pouvez la transmettre à reflect.structof

, qui renverra une valeur reflect.type représentant le type de structure dynamique, que vous pourrez ensuite transmettre à reflect.new pour créer un code reflect.value > , qui représentera une instance de la structure dynamique (en fait un pointeur vers la structure). Par exemple

var result []any
for _, m := range a {
    fields := make([]reflect.StructField, 0, len(m))

    for k, v := range m {
        f := reflect.StructField{
            Name: k,
            Type: reflect.TypeOf(v), // allow for other types, not just strings
        }
        fields = append(fields, f)
    }

    st := reflect.StructOf(fields) // new struct type
    sv := reflect.New(st)          // new struct value

    for k, v := range m {
        sv.Elem(). // dereference struct pointer
                FieldByName(k).         // get the relevant field
                Set(reflect.ValueOf(v)) // set the value of the field
    }

    result = append(result, sv.Interface())
}

🎜🎜https://www.php.cn/link/3722e31eaa9efae6938cc5c435365dfd🎜🎜

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!