改进gconv.Struct转换默认规则，支持不区分大小写的键名与属性名称匹配

geg/util/gconv/gconv_struct1.go

@@ -16,13 +16,13 @@ type User struct {
 func main() {
     user    := (*User)(nil)
 
-    // 使用map直接映射绑定属性值到对象
+    // 使用默认映射规则绑定属性值到对象
     user     = new(User)
     params1 := g.Map{
         "uid"   : 1,
-        "name"  : "john",
-        "pass1" : "123",
-        "pass2" : "123",
+        "Name"  : "john",
+        "PASS1" : "123",
+        "PASS2" : "456",
     }
     if err := gconv.Struct(params1, user); err == nil {
         fmt.Println(user)
@@ -33,8 +33,8 @@ func main() {
     params2 := g.Map {
         "uid"       : 2,
         "name"      : "smith",
-        "password1" : "456",
-        "password2" : "456",
+        "password1" : "111",
+        "password2" : "222",
     }
     if err := gconv.Struct(params2, user); err == nil {
         fmt.Println(user)

geg/util/gconv/gconv_struct2.go

@@ -1,31 +1,28 @@
 package main
 
 import (
-    "gitee.com/johng/gf/g/util/gconv"
-    "gitee.com/johng/gf/g"
     "fmt"
+    "gitee.com/johng/gf/g"
+    "gitee.com/johng/gf/g/util/gconv"
 )
 
-// 演示slice类型属性的赋值
+
+// 使用默认映射规则绑定属性值到对象
 func main() {
     type User struct {
-        Scores []int
+        Uid   int
+        Name  string
+        Pass1 string
+        Pass2 string
     }
-
-    user   := new(User)
-    scores := []interface{}{99, 100, 60, 140}
-
-    // 通过map映射转换
-    if err := gconv.Struct(g.Map{"Scores" : scores}, user); err != nil {
-        fmt.Println(err)
-    } else {
-        g.Dump(user)
+    user    := new(User)
+    params  := g.Map {
+        "uid"   : 1,
+        "Name"  : "john",
+        "PASS1" : "123",
+        "PASS2" : "456",
     }
-
-    // 通过变量映射转换，直接slice赋值
-    if err := gconv.Struct(scores, user); err != nil {
-        fmt.Println(err)
-    } else {
-        g.Dump(user)
+    if err := gconv.Struct(params, user); err == nil {
+        fmt.Println(user)
     }
 }

geg/util/gconv/gconv_struct3.go

@@ -6,24 +6,23 @@ import (
     "fmt"
 )
 
+// 演示slice类型属性的赋值
 func main() {
-    type Score struct {
-        Name   string
-        Result int
-    }
     type User struct {
-        Scores Score
+        Scores []int
     }
 
     user   := new(User)
-    scores := map[string]interface{}{
-        "Scores" : map[string]interface{}{
-            "Name"   : "john",
-            "Result" : 100,
-        },
+    scores := []interface{}{99, 100, 60, 140}
+
+    // 通过map映射转换
+    if err := gconv.Struct(g.Map{"Scores" : scores}, user); err != nil {
+        fmt.Println(err)
+    } else {
+        g.Dump(user)
     }
 
-    // 嵌套struct转换
+    // 通过变量映射转换，直接slice赋值
     if err := gconv.Struct(scores, user); err != nil {
         fmt.Println(err)
     } else {

geg/util/gconv/gconv_struct4.go

@@ -12,7 +12,7 @@ func main() {
         Result int
     }
     type User struct {
-        Scores []Score
+        Scores Score
     }
 
     user   := new(User)
@@ -23,7 +23,7 @@ func main() {
         },
     }
 
-    // 嵌套struct转换，属性为slice类型，数值为map类型
+    // 嵌套struct转换
     if err := gconv.Struct(scores, user); err != nil {
         fmt.Println(err)
     } else {

geg/util/gconv/gconv_struct5.go

@@ -17,19 +17,13 @@ func main() {
 
     user   := new(User)
     scores := map[string]interface{}{
-        "Scores" : []interface{}{
-            map[string]interface{}{
-                "Name"   : "john",
-                "Result" : 100,
-            },
-            map[string]interface{}{
-                "Name"   : "smith",
-                "Result" : 60,
-            },
+        "Scores" : map[string]interface{}{
+            "Name"   : "john",
+            "Result" : 100,
         },
     }
 
-    // 嵌套struct转换，属性为slice类型，数值为slice map类型
+    // 嵌套struct转换，属性为slice类型，数值为map类型
     if err := gconv.Struct(scores, user); err != nil {
         fmt.Println(err)
     } else {

geg/util/gconv/gconv_struct6.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+    "gitee.com/johng/gf/g/util/gconv"
+    "gitee.com/johng/gf/g"
+    "fmt"
+)
+
+func main() {
+    type Score struct {
+        Name   string
+        Result int
+    }
+    type User struct {
+        Scores []Score
+    }
+
+    user   := new(User)
+    scores := map[string]interface{}{
+        "Scores" : []interface{}{
+            map[string]interface{}{
+                "Name"   : "john",
+                "Result" : 100,
+            },
+            map[string]interface{}{
+                "Name"   : "smith",
+                "Result" : 60,
+            },
+        },
+    }
+
+    // 嵌套struct转换，属性为slice类型，数值为slice map类型
+    if err := gconv.Struct(scores, user); err != nil {
+        fmt.Println(err)
+    } else {
+        g.Dump(user)
+    }
+}