定制深拷贝方法，提高深拷贝速度

Author: 520MianXiangDuiXiang520

deepcopy.go

@@ -1,14 +1,76 @@
 package json_diff
 
 import (
-	"bytes"
-	"encoding/gob"
+	"github.com/pkg/errors"
 )
 
-func DeepCopy(dst, src interface{}) error {
-	var buf bytes.Buffer
-	if err := gob.NewEncoder(&buf).Encode(src); err != nil {
-		return err
+func copySlice(src *JsonNode) (*JsonNode, error) {
+	size := len(src.Children)
+	res := NewSliceNode(make([]*JsonNode, size), int(src.Level))
+	for i, child := range src.Children {
+		var newNode *JsonNode
+		var err error
+		switch child.Type {
+		case JsonNodeTypeSlice:
+			newNode, err = copySlice(child)
+			if err != nil {
+				return nil, errors.Wrapf(err, "fail to copy %dst of Slice type", i)
+			}
+		case JsonNodeTypeObject:
+			newNode, err = copyObject(child)
+			if err != nil {
+				return nil, errors.Wrapf(err, "fail to copy %dst of Object type", i)
+			}
+		case JsonNodeTypeValue:
+			newNode, err = copyValue(child)
+			if err != nil {
+				return nil, errors.Wrapf(err, "fail to copy %dst of Value type", i)
+			}
+		}
+		res.Children[i] = newNode
 	}
-	return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
+	return res, nil
+}
+
+func copyValue(src *JsonNode) (*JsonNode, error) {
+	return NewValueNode(src.Value, int(src.Level)), nil
+}
+
+func copyObject(src *JsonNode) (*JsonNode, error) {
+	res := NewObjectNode("", map[string]*JsonNode{}, int(src.Level))
+	for k, v := range src.ChildrenMap {
+		var newNode *JsonNode
+		var err error
+		switch v.Type {
+		case JsonNodeTypeObject:
+			newNode, err = copyObject(v)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to copy %s of Object type", k)
+			}
+		case JsonNodeTypeSlice:
+			newNode, err = copySlice(v)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to copy %s of Slice type", k)
+			}
+		case JsonNodeTypeValue:
+			newNode, err = copyValue(v)
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed to copy %s of Value type", k)
+			}
+		}
+		res.ChildrenMap[k] = newNode
+	}
+	return res, nil
+}
+
+func DeepCopy(src *JsonNode) (*JsonNode, error) {
+	switch src.Type {
+	case JsonNodeTypeObject:
+		return copyObject(src)
+	case JsonNodeTypeSlice:
+		return copySlice(src)
+	case JsonNodeTypeValue:
+		return copyValue(src)
+	}
+	return nil, errors.New("src has an unknown type")
 }

deepcopy_test.go

@@ -5,40 +5,67 @@ import (
 	"testing"
 )
 
+func TestDeepCopy_emptyObject(t *testing.T) {
+	srcStr := "{}"
+	srcNode, _ := Unmarshal([]byte(srcStr))
+	cp, err := DeepCopy(srcNode)
+	if err != nil {
+		t.Errorf("got an error: %v", err)
+	}
+	err = cp.ADD("child", NewValueNode(1, 2))
+	if err != nil {
+		t.Errorf("fail to add child: %v", err)
+	}
+	if _, ok := srcNode.ChildrenMap["child"]; ok {
+		t.Errorf("change source object: %s", srcNode.String())
+	}
+}
+
 func TestDeepCopy(t *testing.T) {
-	fileName := "./test_data/mergeSmoke.json"
+	fileName := "./test_data/deepcopy_test.json"
 	input, err := ioutil.ReadFile(fileName)
 	if err != nil {
 		t.Error("fail to open the ", fileName)
 	}
-	src, _ := Unmarshal(input)
-	type args struct {
-		dst interface{}
-		src interface{}
-	}
-	dst := new(JsonNode)
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{name: "smoke", args: args{
-			dst: dst,
-			src: src,
-		}, wantErr: false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := DeepCopy(tt.args.dst, tt.args.src); (err != nil) != tt.wantErr {
-				t.Errorf("DeepCopy() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			if dst == nil || !dst.Equal(src) {
-				t.Errorf("Values are not equal after DeepCopy, dst is %v, but src is %v", dst, src)
-			}
-			dst.Value = "dst"
-			if dst.Value == src.Value {
-				t.Errorf("dst and src point to the same object")
-			}
-		})
+	srcNode, _ := Unmarshal(input)
+	cp, err := DeepCopy(srcNode)
+	if err != nil {
+		t.Errorf("got an error: %v", err)
+	}
+	err = cp.ADD("add_child", NewValueNode(1, 2))
+	if err != nil {
+		t.Errorf("fail to add child: %v", err)
+	}
+	err = cp.ADD("add_child", NewValueNode(1, 2))
+	if err != nil {
+		t.Errorf("fail to add child: %v", err)
+	}
+	// 更改深层 object
+	path1 := "/obj/obj/c/ce/2/ceb"
+	cpof, ok := cp.Find(path1)
+	if !ok {
+		t.Errorf("can not find: %s in cp node", path1)
+	}
+	cpof.Value = true
+	of, ok := srcNode.Find(path1)
+	if !ok {
+		t.Errorf("can not find: %s in src node", path1)
+	}
+	if of.Value.(bool) {
+		t.Errorf("change source object: %v", cpof.Value)
+	}
+	// 更改深层 slice
+	path2 := "/obj/slice/4/bb/1"
+	cpof, ok = cp.Find(path1)
+	if !ok {
+		t.Errorf("can not find: %s in cp node", path2)
+	}
+	cpof.Value = "ggg"
+	of, ok = srcNode.Find(path2)
+	if !ok {
+		t.Errorf("can not find: %s in src node", path2)
+	}
+	if of.Value.(string) != "jjj" {
+		t.Errorf("change source object: %v", cpof.Value)
 	}
 }

jsondiff.go

@@ -1,11 +1,11 @@
 package json_diff
 
 import (
-    "bytes"
-    "encoding/json"
-    "fmt"
-    "github.com/pkg/errors"
-    "strconv"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"strconv"
 )
 
 func diffSlice(diffs *diffs, path string, source, patch *JsonNode, option JsonDiffOption) {
@@ -120,20 +120,20 @@ func diff(diffs *diffs, path string, source, patch *JsonNode, option JsonDiffOpt
 
 // GetDiffNode 比较两个 JsonNode 之间的差异，并返回 JsonNode 格式的差异结果
 func GetDiffNode(sourceJsonNode, patchJsonNode *JsonNode, options ...JsonDiffOption) *JsonNode {
-    option := JsonDiffOption(0)
-    for _, o := range options {
-        option |= o
-    }
-    diffs := newDiffs()
-    diff(diffs, "", sourceJsonNode, patchJsonNode, option)
-    doOption(diffs, option, sourceJsonNode, patchJsonNode)
-    return diffs.d
+	option := JsonDiffOption(0)
+	for _, o := range options {
+		option |= o
+	}
+	diffs := newDiffs()
+	diff(diffs, "", sourceJsonNode, patchJsonNode, option)
+	doOption(diffs, option, sourceJsonNode, patchJsonNode)
+	return diffs.d
 }
 
 // AsDiffs 比较 patch 相比于 source 的差别，返回 json 格式的差异文档。
 func AsDiffs(source, patch []byte, options ...JsonDiffOption) ([]byte, error) {
-    sourceJsonNode, _ := Unmarshal(source)
-    patchJsonNode, _ := Unmarshal(patch)
+	sourceJsonNode, _ := Unmarshal(source)
+	patchJsonNode, _ := Unmarshal(patch)
 	dict := marshalSlice(GetDiffNode(sourceJsonNode, patchJsonNode, options...))
 	return json.Marshal(dict)
 }
@@ -190,36 +190,35 @@ func merge(srcNode, diffNode *JsonNode) error {
 func MergeDiff(source, diff []byte) ([]byte, error) {
 	diffNode, err := Unmarshal(diff)
 	if err != nil {
-	    return nil, errors.Wrap(err, "fail to unmarshal diff data")
-    }
+		return nil, errors.Wrap(err, "fail to unmarshal diff data")
+	}
 	srcNode, err := Unmarshal(source)
 	if err != nil {
-	    return nil, errors.Wrap(err, "fail to unmarshal source data")
-    }
+		return nil, errors.Wrap(err, "fail to unmarshal source data")
+	}
 	result, err := MergeDiffNode(srcNode, diffNode)
 	if err != nil {
-	    return nil, errors.Wrap(err, "fail to merge diff")
-    }
+		return nil, errors.Wrap(err, "fail to merge diff")
+	}
 	return Marshal(result)
 }
 
 // MergeDiffNode 将 JsonNode 类型的 diffs 应用于源 source 上，并返回合并后的新 jsonNode 对象
 // 如果 diffs 不合法，第二个参数将会返回 BadDiffsError
 func MergeDiffNode(source, diffs *JsonNode) (*JsonNode, error) {
-    if diffs == nil {
-        return source, nil
-    }
-    if diffs.Type != JsonNodeTypeSlice {
-        return nil, errors.New("bad diffs")
-    }
-    copyNode := new(JsonNode)
-    err := DeepCopy(copyNode, source)
-    if err != nil {
-        return nil, errors.Wrap(err, "fail to deep copy source")
-    }
-    err = merge(copyNode, diffs)
-    if err != nil {
-        return nil, errors.Wrap(err, "fail to merge")
-    }
-    return copyNode, nil
+	if diffs == nil {
+		return source, nil
+	}
+	if diffs.Type != JsonNodeTypeSlice {
+		return nil, errors.New("bad diffs")
+	}
+	copyNode, err := DeepCopy(source)
+	if err != nil {
+		return nil, errors.Wrap(err, "fail to deep copy source")
+	}
+	err = merge(copyNode, diffs)
+	if err != nil {
+		return nil, errors.Wrap(err, "fail to merge")
+	}
+	return copyNode, nil
 }

jsondiff_test.go

@@ -75,11 +75,10 @@ func Test_merge_smoke(t *testing.T) {
 			want: wantNode,
 		}
 	}
-
 	for _, cs := range testCases {
 		t.Run(cs.name, func(t *testing.T) {
 			src := new(JsonNode)
-			err := DeepCopy(src, cs.args.srcNode)
+			src, err := DeepCopy(cs.args.srcNode)
 			if err != nil {
 				t.Errorf("fail to deepcopy src object")
 			}
@@ -150,8 +149,8 @@ func TestGetDiff(t *testing.T) {
 	}
 	for _, tt := range tss {
 		t.Run(tt.name, func(t *testing.T) {
-		    src, _ := Unmarshal(tt.args.source)
-		    pat, _ := Unmarshal(tt.args.patch)
+			src, _ := Unmarshal(tt.args.source)
+			pat, _ := Unmarshal(tt.args.patch)
 			diffs := GetDiffNode(src, pat, tt.args.options...)
 			if !eq(diffs, tt.want) {
 				got, _ := Marshal(diffs)

test_data/deepcopy_test.json

@@ -0,0 +1,42 @@
+{
+  "obj": {
+    "obj": {
+      "a": false,
+      "b": 1,
+      "c": {
+        "cc": 1,
+        "cd": true,
+        "ce": [
+          1,
+          2,
+          {
+            "cea": 1,
+            "ceb": false,
+            "cec": [1, 2]
+          },
+          [3, 4, 5]
+        ]
+      }
+    },
+    "slice": [
+      1, 2, 3, 4,
+      {
+        "ba": 1,
+        "bb": [
+          12, "jjj", true, {
+            "bba": 7
+          }
+        ],
+        "bc": 3,
+        "bd": true
+      },
+      true, false, "fvv"
+    ],
+    "va": 1,
+    "va2": -0,
+    "va3": false,
+    "va4": true,
+    "va5": "sds",
+    "va6": 2e8
+  }
+}