blackteay/gf
1
0
Fork 0
mirror of https://github.com/gogf/gf.git synced 2025-04-05 11:18:50 +08:00
Code Issues Projects Releases Wiki Activity

fix issue #2381 (#2382)

Browse Source 
* fix issue #2381

* up

* up
This commit is contained in:
John Guo 2023-01-03 11:00:23 +08:00 committed by GitHub
parent 31e44062a8
commit 5884a0e05f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 381 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
encoding/gjson/gjson_api.go
View File

@ -208,5 +208,8 @@ func (j *Json) Dump() {
}
j.mu.RLock()
defer j.mu.RUnlock()
if j.p == nil {
return
}
gutil.Dump(*j.p)
}

8
encoding/gjson/gjson_implements.go
View File

@ -50,3 +50,11 @@ func (j *Json) Interfaces() []interface{} {
}
return j.Array()
}
// String returns current Json object as string.
func (j *Json) String() string {
if j.IsNil() {
return ""
}
return j.MustToJsonString()
}

2
encoding/gjson/gjson_z_unit_test.go
View File

@ -376,7 +376,7 @@ func Test_Convert2(t *testing.T) {
j := gjson.New(`{"name":"gf","time":"2019-06-12"}`)
t.Assert(j.Interface().(g.Map)["name"], "gf")
t.Assert(j.Get("name1").Map(), nil)
t.AssertNE(j.GetJson("name1"), nil)
t.Assert(j.GetJson("name1"), nil)
t.Assert(j.GetJsons("name1"), nil)
t.Assert(j.GetJsonMap("name1"), nil)
t.Assert(j.Contains("name1"), false)

179
util/gconv/gconv_map.go
View File

@ -15,6 +15,13 @@ import (
"github.com/gogf/gf/v2/internal/utils"
)
type recursiveType string
const (
recursiveTypeAuto recursiveType = "auto"
recursiveTypeTrue recursiveType = "true"
)
// Map converts any variable `value` to map[string]interface{}. If the parameter `value` is not a
// map/struct/*struct type, then the conversion will fail and returns nil.
//
@ -22,7 +29,7 @@ import (
// tags that will be detected, otherwise it detects the tags in order of:
// gconv, json, field name.
func Map(value interface{}, tags ...string) map[string]interface{} {
return doMapConvert(value, false, tags...)
return doMapConvert(value, recursiveTypeAuto, tags...)
}
// MapDeep does Map function recursively, which means if the attribute of `value`
@ -30,14 +37,14 @@ func Map(value interface{}, tags ...string) map[string]interface{} {
// a map[string]interface{} type variable.
// Also see Map.
func MapDeep(value interface{}, tags ...string) map[string]interface{} {
return doMapConvert(value, true, tags...)
return doMapConvert(value, recursiveTypeTrue, tags...)
}
// doMapConvert implements the map converting.
// It automatically checks and converts json string to map if `value` is string/[]byte.
//
// TODO completely implement the recursive converting for all types, especially the map.
func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]interface{} {
func doMapConvert(value interface{}, recursive recursiveType, tags ...string) map[string]interface{} {
if value == nil {
return nil
}
@ -73,7 +80,15 @@ func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]
}
case map[interface{}]interface{}:
for k, v := range r {
dataMap[String(k)] = doMapConvertForMapOrStructValue(false, v, recursive, newTags...)
dataMap[String(k)] = doMapConvertForMapOrStructValue(
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: v,
RecursiveType: recursive,
RecursiveOption: recursive == recursiveTypeTrue,
Tags: newTags,
},
)
}
case map[interface{}]string:
for k, v := range r {
@ -120,10 +135,18 @@ func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]
dataMap[k] = v
}
case map[string]interface{}:
if recursive {
if recursive == recursiveTypeTrue {
// A copy of current map.
for k, v := range r {
dataMap[k] = doMapConvertForMapOrStructValue(false, v, recursive, newTags...)
dataMap[k] = doMapConvertForMapOrStructValue(
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: v,
RecursiveType: recursive,
RecursiveOption: recursive == recursiveTypeTrue,
Tags: newTags,
},
)
}
} else {
// It returns the map directly without any changing.
@ -131,7 +154,15 @@ func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]
}
case map[int]interface{}:
for k, v := range r {
dataMap[String(k)] = doMapConvertForMapOrStructValue(false, v, recursive, newTags...)
dataMap[String(k)] = doMapConvertForMapOrStructValue(
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: v,
RecursiveType: recursive,
RecursiveOption: recursive == recursiveTypeTrue,
Tags: newTags,
},
)
}
case map[int]string:
for k, v := range r {
@ -171,7 +202,15 @@ func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]
}
}
case reflect.Map, reflect.Struct, reflect.Interface:
convertedValue := doMapConvertForMapOrStructValue(true, value, recursive, newTags...)
convertedValue := doMapConvertForMapOrStructValue(
doMapConvertForMapOrStructValueInput{
IsRoot: true,
Value: value,
RecursiveType: recursive,
RecursiveOption: recursive == recursiveTypeTrue,
Tags: newTags,
},
)
if m, ok := convertedValue.(map[string]interface{}); ok {
return m
}
@ -183,16 +222,25 @@ func doMapConvert(value interface{}, recursive bool, tags ...string) map[string]
return dataMap
}
func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive bool, tags ...string) interface{} {
if isRoot == false && recursive == false {
return value
type doMapConvertForMapOrStructValueInput struct {
IsRoot bool // It returns directly if it is not root and with no recursive converting.
Value interface{} // Current operation value.
RecursiveType recursiveType // The type from top function entry.
RecursiveOption bool // Whether convert recursively for `current` operation.
Tags []string // Map key mapping.
}
func doMapConvertForMapOrStructValue(in doMapConvertForMapOrStructValueInput) interface{} {
if in.IsRoot == false && in.RecursiveOption == false {
return in.Value
}
var reflectValue reflect.Value
if v, ok := value.(reflect.Value); ok {
if v, ok := in.Value.(reflect.Value); ok {
reflectValue = v
value = v.Interface()
in.Value = v.Interface()
} else {
reflectValue = reflect.ValueOf(value)
reflectValue = reflect.ValueOf(in.Value)
}
reflectKind := reflectValue.Kind()
// If it is a pointer, we should find its real data type.
@ -208,10 +256,13 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
)
for _, k := range mapKeys {
dataMap[String(k.Interface())] = doMapConvertForMapOrStructValue(
false,
reflectValue.MapIndex(k).Interface(),
recursive,
tags...,
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: reflectValue.MapIndex(k).Interface(),
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
},
)
}
return dataMap
@ -219,11 +270,19 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
case reflect.Struct:
var dataMap = make(map[string]interface{})
// Map converting interface check.
if v, ok := value.(iMapStrAny); ok {
if v, ok := in.Value.(iMapStrAny); ok {
// Value copy, in case of concurrent safety.
for mapK, mapV := range v.MapStrAny() {
if recursive {
dataMap[mapK] = doMapConvertForMapOrStructValue(false, mapV, recursive, tags...)
if in.RecursiveOption {
dataMap[mapK] = doMapConvertForMapOrStructValue(
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: mapV,
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
},
)
} else {
dataMap[mapK] = mapV
}
@ -247,7 +306,7 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
}
mapKey = ""
fieldTag := rtField.Tag
for _, tag := range tags {
for _, tag := range in.Tags {
if mapKey = fieldTag.Get(tag); mapKey != "" {
break
}
@ -274,7 +333,7 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
}
}
}
if recursive || rtField.Anonymous {
if in.RecursiveOption || rtField.Anonymous {
// Do map converting recursively.
var (
rvAttrField = rvField
@ -292,25 +351,48 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
continue
}
var (
hasNoTag = mapKey == fieldName
rvAttrInterface = rvAttrField.Interface()
hasNoTag = mapKey == fieldName
// DO NOT use rvAttrField.Interface() here,
// as it might be changed from pointer to struct.
rvInterface = rvField.Interface()
)
if hasNoTag && rtField.Anonymous {
switch {
case hasNoTag && rtField.Anonymous:
// It means this attribute field has no tag.
// Overwrite the attribute with sub-struct attribute fields.
anonymousValue := doMapConvertForMapOrStructValue(false, rvAttrInterface, true, tags...)
anonymousValue := doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: rvInterface,
RecursiveType: in.RecursiveType,
RecursiveOption: true,
Tags: in.Tags,
})
if m, ok := anonymousValue.(map[string]interface{}); ok {
for k, v := range m {
dataMap[k] = v
}
} else {
dataMap[mapKey] = rvAttrInterface
dataMap[mapKey] = rvInterface
}
} else if !hasNoTag && rtField.Anonymous {
// It means this attribute field has desired tag.
dataMap[mapKey] = doMapConvertForMapOrStructValue(false, rvAttrInterface, true, tags...)
} else {
dataMap[mapKey] = doMapConvertForMapOrStructValue(false, rvAttrInterface, recursive, tags...)
// It means this attribute field has desired tag.
case !hasNoTag && rtField.Anonymous:
dataMap[mapKey] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: rvInterface,
RecursiveType: in.RecursiveType,
RecursiveOption: true,
Tags: in.Tags,
})
default:
dataMap[mapKey] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: rvInterface,
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
})
}
// The struct attribute is type of slice.
@ -323,7 +405,13 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
array := make([]interface{}, length)
for arrayIndex := 0; arrayIndex < length; arrayIndex++ {
array[arrayIndex] = doMapConvertForMapOrStructValue(
false, rvAttrField.Index(arrayIndex), recursive, tags...,
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: rvAttrField.Index(arrayIndex),
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
},
)
}
dataMap[mapKey] = array
@ -334,10 +422,13 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
)
for _, k := range mapKeys {
nestedMap[String(k.Interface())] = doMapConvertForMapOrStructValue(
false,
rvAttrField.MapIndex(k).Interface(),
recursive,
tags...,
doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: rvAttrField.MapIndex(k).Interface(),
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
},
)
}
dataMap[mapKey] = nestedMap
@ -358,7 +449,7 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
}
}
if len(dataMap) == 0 {
return value
return in.Value
}
return dataMap
@ -370,11 +461,17 @@ func doMapConvertForMapOrStructValue(isRoot bool, value interface{}, recursive b
}
array := make([]interface{}, reflectValue.Len())
for i := 0; i < length; i++ {
array[i] = doMapConvertForMapOrStructValue(false, reflectValue.Index(i), recursive, tags...)
array[i] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
IsRoot: false,
Value: reflectValue.Index(i),
RecursiveType: in.RecursiveType,
RecursiveOption: in.RecursiveType == recursiveTypeTrue,
Tags: in.Tags,
})
}
return array
}
return value
return in.Value
}
// MapStrStr converts `value` to map[string]string.

174
util/gconv/gconv_z_unit_all_test.go
View File

@ -7,12 +7,12 @@
package gconv_test
import (
"github.com/gogf/gf/v2/container/gvar"
"math"
"testing"
"time"
"github.com/gogf/gf/v2/container/gtype"
"github.com/gogf/gf/v2/container/gvar"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/test/gtest"
@ -41,103 +41,6 @@ func (s1 S1) Error() string {
return "22222"
}
// https://github.com/gogf/gf/issues/1227
func Test_Issue1227(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
type StructFromIssue1227 struct {
Name string `json:"n1"`
}
tests := []struct {
name string
origin interface{}
want string
}{
{
name: "Case1",
origin: `{"n1":"n1"}`,
want: "n1",
},
{
name: "Case2",
origin: `{"name":"name"}`,
want: "",
},
{
name: "Case3",
origin: `{"NaMe":"NaMe"}`,
want: "",
},
{
name: "Case4",
origin: g.Map{"n1": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"NaMe": "n1"},
want: "n1",
},
}
for _, tt := range tests {
p := StructFromIssue1227{}
if err := gconv.Struct(tt.origin, &p); err != nil {
t.Error(err)
}
t.Assert(p.Name, tt.want)
}
})
// Chinese key.
gtest.C(t, func(t *gtest.T) {
type StructFromIssue1227 struct {
Name string `json:"中文Key"`
}
tests := []struct {
name string
origin interface{}
want string
}{
{
name: "Case1",
origin: `{"中文Key":"n1"}`,
want: "n1",
},
{
name: "Case2",
origin: `{"Key":"name"}`,
want: "",
},
{
name: "Case3",
origin: `{"NaMe":"NaMe"}`,
want: "",
},
{
name: "Case4",
origin: g.Map{"中文Key": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"中文KEY": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"KEY": "n1"},
want: "",
},
}
for _, tt := range tests {
p := StructFromIssue1227{}
if err := gconv.Struct(tt.origin, &p); err != nil {
t.Error(err)
}
t.Assert(p.Name, tt.want)
}
})
}
func Test_Bool_All(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
var any interface{} = nil
@ -1545,76 +1448,3 @@ func Test_Struct_Time_All(t *testing.T) {
t.Assert(user.CreateTime.Time.UTC().String(), now.UTC().String())
})
}
func Test_Issue1946(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
type B struct {
init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
init: gtype.NewBool(true),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.init.Val(), true)
})
// It cannot change private attribute.
gtest.C(t, func(t *gtest.T) {
type B struct {
init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
init: gtype.NewBool(true),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"init": 0,
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.init.Val(), true)
})
// It can change public attribute.
gtest.C(t, func(t *gtest.T) {
type B struct {
Init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
Init: gtype.NewBool(),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"Init": 1,
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.Init.Val(), true)
})
}

225
util/gconv/gconv_z_unit_issue_test.go Normal file
View File

@ -0,0 +1,225 @@
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gconv_test
import (
"testing"
"github.com/gogf/gf/v2/container/gtype"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/test/gtest"
"github.com/gogf/gf/v2/util/gconv"
)
// https://github.com/gogf/gf/issues/1227
func Test_Issue1227(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
type StructFromIssue1227 struct {
Name string `json:"n1"`
}
tests := []struct {
name string
origin interface{}
want string
}{
{
name: "Case1",
origin: `{"n1":"n1"}`,
want: "n1",
},
{
name: "Case2",
origin: `{"name":"name"}`,
want: "",
},
{
name: "Case3",
origin: `{"NaMe":"NaMe"}`,
want: "",
},
{
name: "Case4",
origin: g.Map{"n1": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"NaMe": "n1"},
want: "n1",
},
}
for _, tt := range tests {
p := StructFromIssue1227{}
if err := gconv.Struct(tt.origin, &p); err != nil {
t.Error(err)
}
t.Assert(p.Name, tt.want)
}
})
// Chinese key.
gtest.C(t, func(t *gtest.T) {
type StructFromIssue1227 struct {
Name string `json:"中文Key"`
}
tests := []struct {
name string
origin interface{}
want string
}{
{
name: "Case1",
origin: `{"中文Key":"n1"}`,
want: "n1",
},
{
name: "Case2",
origin: `{"Key":"name"}`,
want: "",
},
{
name: "Case3",
origin: `{"NaMe":"NaMe"}`,
want: "",
},
{
name: "Case4",
origin: g.Map{"中文Key": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"中文KEY": "n1"},
want: "n1",
},
{
name: "Case5",
origin: g.Map{"KEY": "n1"},
want: "",
},
}
for _, tt := range tests {
p := StructFromIssue1227{}
if err := gconv.Struct(tt.origin, &p); err != nil {
t.Error(err)
}
t.Assert(p.Name, tt.want)
}
})
}
func Test_Issue1946(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
type B struct {
init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
init: gtype.NewBool(true),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.init.Val(), true)
})
// It cannot change private attribute.
gtest.C(t, func(t *gtest.T) {
type B struct {
init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
init: gtype.NewBool(true),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"init": 0,
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.init.Val(), true)
})
// It can change public attribute.
gtest.C(t, func(t *gtest.T) {
type B struct {
Init *gtype.Bool
Name string
}
type A struct {
B *B
}
a := &A{
B: &B{
Init: gtype.NewBool(),
},
}
err := gconv.Struct(g.Map{
"B": g.Map{
"Init": 1,
"Name": "init",
},
}, a)
t.AssertNil(err)
t.Assert(a.B.Name, "init")
t.Assert(a.B.Init.Val(), true)
})
}
// https://github.com/gogf/gf/issues/2381
func Test_Issue2381(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
type Inherit struct {
Id int64 `json:"id" description:"Id"`
Flag *gjson.Json `json:"flag" description:"标签"`
Title string `json:"title" description:"标题"`
CreatedAt *gtime.Time `json:"createdAt" description:"创建时间"`
}
type Test1 struct {
Inherit
}
type Test2 struct {
Inherit
}
var (
a1 Test1
a2 Test2
)
a1 = Test1{
Inherit{
Id: 2,
Flag: gjson.New("[1, 2]"),
Title: "测试",
CreatedAt: gtime.Now(),
},
}
err := gconv.Scan(a1, &a2)
t.AssertNil(err)
t.Assert(a1.Id, a2.Id)
t.Assert(a1.Title, a2.Title)
t.Assert(a1.CreatedAt, a2.CreatedAt)
t.Assert(a1.Flag.String(), a2.Flag.String())
})
}

8
util/gconv/gconv_z_unit_map_test.go
View File

@ -592,10 +592,10 @@ func TestMapsDeep(t *testing.T) {
})
gtest.C(t, func(t *gtest.T) {
string_interface_map_list := []map[string]interface{}{}
string_interface_map_list = append(string_interface_map_list, map[string]interface{}{"id": 100})
string_interface_map_list = append(string_interface_map_list, map[string]interface{}{"id": 200})
list := gconv.MapsDeep(string_interface_map_list)
stringInterfaceMapList := make([]map[string]interface{}, 0)
stringInterfaceMapList = append(stringInterfaceMapList, map[string]interface{}{"id": 100})
stringInterfaceMapList = append(stringInterfaceMapList, map[string]interface{}{"id": 200})
list := gconv.MapsDeep(stringInterfaceMapList)
t.Assert(len(list), 2)
t.Assert(list[0]["id"], 100)
t.Assert(list[1]["id"], 200)