diff --git a/g/database/gdb/gdb_unit_init_test.go b/g/database/gdb/gdb_unit_init_test.go
index 0300fa8f0..d460f1fa3 100644
--- a/g/database/gdb/gdb_unit_init_test.go
+++ b/g/database/gdb/gdb_unit_init_test.go
@@ -3,6 +3,7 @@ package gdb_test
 import (
     "github.com/gogf/gf/g/database/gdb"
     "github.com/gogf/gf/g/test/gtest"
+	"os"
 )
 
 var (
@@ -13,7 +14,7 @@ var (
 // 初始化连接参数。
 // 测试前需要修改连接参数。
 func init() {
-	gdb.AddDefaultConfigNode(gdb.ConfigNode{
+	node := gdb.ConfigNode{
 		Host:     "127.0.0.1",
 		Port:     "3306",
 		User:     "root",
@@ -22,8 +23,13 @@ func init() {
 		Type:     "mysql",
 		Role:     "master",
 		Charset:  "utf8",
-        Priority: 1,
-	})
+		Priority: 1,
+	}
+	hostname, _ := os.Hostname()
+	if hostname == "ijohn" {
+		node.Pass = "12345678"
+	}
+	gdb.AddDefaultConfigNode(node)
 	if r, err := gdb.New(); err != nil {
         gtest.Fatal(err)
 	} else {
diff --git a/g/util/gconv/gconv_map.go b/g/util/gconv/gconv_map.go
index dd3834b45..75fa89bc8 100644
--- a/g/util/gconv/gconv_map.go
+++ b/g/util/gconv/gconv_map.go
@@ -13,105 +13,106 @@ import (
 // 任意类型转换为 map[string]interface{} 类型,
 // 如果给定的输入参数i不是map类型，那么转换会失败，返回nil.
 // 当i为struct对象时，第二个参数noTagCheck表示不检测json标签，否则将会使用json tag作为map的键名。
-func Map(i interface{}, noTagCheck...bool) map[string]interface{} {
-    if i == nil {
+func Map(value interface{}, noTagCheck...bool) map[string]interface{} {
+    if value == nil {
         return nil
     }
-    if r, ok := i.(map[string]interface{}); ok {
+    if r, ok := value.(map[string]interface{}); ok {
         return r
     } else {
         // 仅对常见的几种map组合进行断言，最后才会使用反射
         m := make(map[string]interface{})
-        switch i.(type) {
+        switch value.(type) {
             case map[interface{}]interface{}:
-                for k, v := range i.(map[interface{}]interface{}) {
+                for k, v := range value.(map[interface{}]interface{}) {
                     m[String(k)] = v
                 }
             case map[interface{}]string:
-                for k, v := range i.(map[interface{}]string) {
+                for k, v := range value.(map[interface{}]string) {
                     m[String(k)] = v
                 }
             case map[interface{}]int:
-                for k, v := range i.(map[interface{}]int) {
+                for k, v := range value.(map[interface{}]int) {
                     m[String(k)] = v
                 }
             case map[interface{}]uint:
-                for k, v := range i.(map[interface{}]uint) {
+                for k, v := range value.(map[interface{}]uint) {
                     m[String(k)] = v
                 }
             case map[interface{}]float32:
-                for k, v := range i.(map[interface{}]float32) {
+                for k, v := range value.(map[interface{}]float32) {
                     m[String(k)] = v
                 }
             case map[interface{}]float64:
-                for k, v := range i.(map[interface{}]float64) {
+                for k, v := range value.(map[interface{}]float64) {
                     m[String(k)] = v
                 }
 
             case map[string]bool:
-                for k, v := range i.(map[string]bool) {
+                for k, v := range value.(map[string]bool) {
                     m[k] = v
                 }
             case map[string]int:
-                for k, v := range i.(map[string]int) {
+                for k, v := range value.(map[string]int) {
                     m[k] = v
                 }
             case map[string]uint:
-                for k, v := range i.(map[string]uint) {
+                for k, v := range value.(map[string]uint) {
                     m[k] = v
                 }
             case map[string]float32:
-                for k, v := range i.(map[string]float32) {
+                for k, v := range value.(map[string]float32) {
                     m[k] = v
                 }
             case map[string]float64:
-                for k, v := range i.(map[string]float64) {
+                for k, v := range value.(map[string]float64) {
                     m[k] = v
                 }
 
             case map[int]interface{}:
-                for k, v := range i.(map[int]interface{}) {
+                for k, v := range value.(map[int]interface{}) {
                     m[String(k)] = v
                 }
             case map[int]string:
-                for k, v := range i.(map[int]string) {
+                for k, v := range value.(map[int]string) {
                     m[String(k)] = v
                 }
             case map[uint]string:
-                for k, v := range i.(map[uint]string) {
+                for k, v := range value.(map[uint]string) {
                     m[String(k)] = v
                 }
             // 不是常见类型，则使用反射
             default:
-                rv   := reflect.ValueOf(i)
+                rv   := reflect.ValueOf(value)
                 kind := rv.Kind()
                 // 如果是指针，那么需要转换到指针对应的数据项，以便识别真实的类型
                 if kind == reflect.Ptr {
                     rv   = rv.Elem()
                     kind = rv.Kind()
                 }
-                if kind == reflect.Map {
-                    ks := rv.MapKeys()
-                    for _, k := range ks {
-                        m[String(k.Interface())] = rv.MapIndex(k).Interface()
-                    }
-                } else if kind == reflect.Struct {
-                    rt   := rv.Type()
-                    name := ""
-                    for i := 0; i < rv.NumField(); i++ {
-                        // 检查tag, 支持gconv, json标签, 优先使用gconv
-                        if len(noTagCheck) == 0 || !noTagCheck[0] {
-                            tag := rt.Field(i).Tag
-                            if name = tag.Get("gconv"); name == "" {
-                                if name = tag.Get("json"); name == "" {
-                                    name = rt.Field(i).Name
+                switch kind {
+                    case reflect.Map:
+                        ks := rv.MapKeys()
+                        for _, k := range ks {
+                            m[String(k.Interface())] = rv.MapIndex(k).Interface()
+                        }
+                    case reflect.Struct:
+                        rt   := rv.Type()
+                        name := ""
+                        for i := 0; i < rv.NumField(); i++ {
+                            // 检查tag, 支持gconv, json标签, 优先使用gconv
+                            if len(noTagCheck) == 0 || !noTagCheck[0] {
+                                tag := rt.Field(i).Tag
+                                if name = tag.Get("gconv"); name == "" {
+                                    if name = tag.Get("json"); name == "" {
+                                        name = rt.Field(i).Name
+                                    }
                                 }
                             }
+                            m[name] = rv.Field(i).Interface()
                         }
-                        m[name] = rv.Field(i).Interface()
-                    }
-                } else {
-                    return nil
+                    default:
+                        return nil
                 }
         }
         return m
diff --git a/g/util/gconv/gconv_z_unit_map_test.go b/g/util/gconv/gconv_z_unit_map_test.go
index f2403d43c..ec3e36824 100644
--- a/g/util/gconv/gconv_z_unit_map_test.go
+++ b/g/util/gconv/gconv_z_unit_map_test.go
@@ -36,3 +36,4 @@ func Test_Map(t *testing.T) {
         })
     })
 }
+