Struct转换

    gconv模块执行struct转换的方法仅有两个，定义如下：

    其中：

    1. params为需要转换到struct的变量参数，可以为任意数据类型，常见的数据类型为map；
    2. pointer为需要执行转的目标struct对象，这个参数必须为该struct的对象指针，转换成功后该对象的属性将会更新；
    3. mapping为自定义的map键名到strcut属性之间的映射关系，此时params参数必须为map类型，否则该参数无意义；
    4. StructDeep相比较于Struct方法，区别是支持递归转换，即会同时递归转换其属性中的结构体对象，特别用于转换带有继承结构的自定义struct，详见后续示例；

    gconv模块的struct转换特性非常强大，支持任意数据类型到struct属性的映射转换。在没有提供自定义mapping转换规则的情况下，默认的转换规则如下：

    1. struct中需要匹配的属性必须为公开属性(首字母大写)；
    2. 根据params类型的不同，逻辑会有不同：
      • params参数为map: 键名会自动按照 不区分大小写 且 忽略-/_/空格符号 的形式与struct属性进行匹配；
      • params参数为其他类型: 将会把该变量值与struct的第一个属性进行匹配；
      • 此外，如果struct的属性为复杂数据类型如slice,map,strcut那么会进行递归匹配赋值；
    3. 如果匹配成功，那么将键值赋值给属性，如果无法匹配，那么忽略该键值；

    以下是几个匹配的示例：

    1. map键名    struct属性     是否匹配
    3. Email      Email          match
    4. nickname   NickName       match
    5. NICKNAME   NickName       match
    6. Nick-Name  NickName       match
    7. nick_name  NickName       match
    8. nick name  NickName       match
    9. NickName   Nick_Name      match
    10. Nick-name  Nick_Name      match
    11. nick_name  Nick_Name      match
    1. package main
    3. import (
    4.     "github.com/gogf/gf/frame/g"
    5.     "github.com/gogf/gf/util/gconv"
    6. )
    8. func main() {
    9.     type User struct {
    10.         Uid  int
    11.         Name string
    12.     }
    13.     user := (*User)(nil)
    14.     params := g.Map{
    15.         "uid":  1,
    16.         "name": "john",
    17.     }
    18.     err := gconv.Struct(params, &user)
    19.     if err != nil {
    20.         panic(err)
    21.     }
    22.     g.Dump(user)
    23. }

    执行后，输出结果为：

    1. {
    2.     "Name": "john",
    3.     "Uid": 1
    4. }

    递归转换是指当struct对象包含子对象时，可以将params参数数据（第一个参数）同时递归地映射到其子对象上，常用于带有继承对象的struct上。

    可以使用StructDeep方法实现递归转换。

    1. package main
    3. import (
    5. )
    7. func main() {
    8.     type Ids struct {
    9.         Id         int    `json:"id"`
    10.         Uid        int    `json:"uid"`
    11.     }
    12.     type Base struct {
    13.         Ids
    14.         CreateTime string `json:"create_time"`
    15.     }
    16.     type User struct {
    17.         Base
    18.         Passport   string `json:"passport"`
    19.         Password   string `json:"password"`
    20.         Nickname   string `json:"nickname"`
    21.     }
    22.     data := g.Map{
    23.         "id"          : 1,
    24.         "uid"         : 100,
    25.         "passport"    : "john",
    26.         "password"    : "123456",
    27.         "nickname"    : "John",
    28.         "create_time" : "2019",
    29.     }
    30.     user := new(User)
    31.     gconv.StructDeep(data, user)
    32.     g.Dump(user)
    33. }

    执行后，终端输出结果为：

    package main

import (
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/gf/util/gconv"
)

type User struct {
    Uid      int
    Name     string
    Site_Url string
    NickName string
    Pass1    string `gconv:"password1"`
    Pass2    string `gconv:"password2"`
}

func main() {
    user    := (*User)(nil)

    // 使用默认映射规则绑定属性值到对象
    user     = new(User)
    params1 := g.Map{
        "uid"       : 1,
        "Name"      : "john",
        "siteurl"   : "https://goframe.org",
        "nick_name" : "johng",
        "PASS1"     : "123",
        "PASS2"     : "456",
    }
    if err := gconv.Struct(params1, user); err == nil {
        g.Dump(user)
    }

    // 使用struct tag映射绑定属性值到对象
    user     = new(User)
    params2 := g.Map {
        "uid"       : 2,
        "name"      : "smith",
        "site-url"  : "https://goframe.org",
        "nick name" : "johng",
        "password1" : "111",
        "password2" : "222",
    }
    if err := gconv.Struct(params2, user); err == nil {
        g.Dump(user)
    }
}

    执行后，输出结果为：

    {
    "Uid": 1,
    "Name": "john",
    "Site_Url": "https://goframe.org",
    "NickName": "johng",
    "Pass1": "123",
    "Pass2": "456"
}
{
    "Uid": 2,
    "Name": "smith",
    "Site_Url": "https://goframe.org",
    "NickName": "johng",
    "Pass1": "111",
    "Pass2": "222"
}

    属性支持struct对象或者struct对象指针(目标为指针时，转换时会自动初始化)转换。

    package main

import (
    "github.com/gogf/gf/util/gconv"
    "github.com/gogf/gf/frame/g"
    "fmt"
)

func main() {
    type Score struct {
        Name   string
        Result int
    }
    type User1 struct {
        Scores Score
    }
    type User2 struct {
        Scores *Score
    }

    user1  := new(User1)
    user2  := new(User2)
    scores := g.Map{
        "Scores": g.Map{
            "Name":   "john",
            "Result": 100,
        },
    }

    if err := gconv.Struct(scores, user1); err != nil {
        fmt.Println(err)
    } else {
        g.Dump(user1)
    }
    if err := gconv.Struct(scores, user2); err != nil {
        fmt.Println(err)
    } else {
        g.Dump(user2)
    }
}

    执行后，输出结果为：

    {
    "Scores": {
        "Name": "john",
        "Result": 100
    }
}
{
    "Scores": {
        "Name": "john",
        "Result": 100
    }
}

    执行后，输出结果为：

    {
    "Scores": [
        {
            "Name": "john",
            "Result": 100
        },
        {
            "Name": "smith",
            "Result": 60
        }
    ]
}

    package main

import (
    "github.com/gogf/gf/util/gconv"
    "github.com/gogf/gf/frame/g"
    "fmt"
)

func main() {
    type Score struct {
        Name   string
        Result int
    }
    type User struct {
        Scores []Score
    }

    user   := new(User)
    scores := g.Map{
        "Scores": g.Map{
            "Name":   "john",
            "Result": 100,
        },
    }

    // 嵌套struct转换，属性为slice类型，数值为map类型
    if err := gconv.Struct(scores, user); err != nil {
        fmt.Println(err)
    } else {
        g.Dump(user)
    }
}

    {
    "Scores": [
        {
            "Name": "john",
            "Result": 100
        }
    ]
}

    

    执行后，输出结果为：