在递归生成json路径时所遇到的Slice-append操作的问题

我们的需求是为根据 json 每一个 value 生成从 root 到key的path

（为了方便说明我们暂时不考虑数组的情况，只考虑 object/number/bool/string）

举个例子，对于以下 json 字符串

{
  "a": {
    "b":{
      "c":{
        "d0": "d0",
        "d1": "d1",
        "d2": "d2"
      }
    }
  }
}

我们希望最终生成以下形式

a.b.c.d0 = d0
a.b.c.d1 = d1
a.b.c.d2 = d2

为此我们我们定义了以下结构

type Entry struct{path []string
  val  interface{}}

然后我们通过定义一个递归的函数来执行以下

func RecurseJson(jsonObj interface{}, path []string)([]*Entry, error){switch jsonObj.(type){case map[string]interface{}: //json object
        m := jsonObj.(map[string]interface{})
        var ret []*Entry
        for k, v := range m{newPath, err := RecurseJson(v, append(path, k)) // 递归
            if err != nil {return nil, err}
            ret = append(ret, newPath...)
        }
        return ret, nil

    default:
        return []*Entry{
            {
                path: path,
                val: jsonObj,
            },
        }, nil
    }
}

我们使用一个测试函数来测试执行结果

func TestRecurseJson(t *testing.T) {var obj interface{}
    err := json.Unmarshal([]byte(testJson), &obj)
    assert.NoError(t, err)

    ret, err := RecurseJson(obj, nil)
    assert.NoError(t, err)

    for _, entry := range ret{fmt.Printf("%v \t = %v\n", strings.Join(entry.path, "."), entry.val)
    }
}

输出的结果是

a.b.c.d2      = d0
a.b.c.d2      = d1
a.b.c.d2      = d2

而我们期望输出的结果是

a.b.c.d0      = d0
a.b.c.d1      = d1
a.b.c.d2      = d2

二者之间，第一行和第二行的 path 最末尾不一致，那么问题出在哪里呢？通过打点分析，发现在执行下面这一行的时候出现了问题

newPath, err := RecurseJson(v, append(path, k))

更细化一点，将他们拆分成两行

sub := append(path, k)
newPath, err := RecurseJson(v, sub)

打点发现在第一行，也就是 append 的地方会遇到问题，append 之后会将我们上一次 append 的结果覆盖掉，那么为什么会这样呢？通过打点可以发现，当我们递归路径进入到 c 之后，也就是 path 为["a", "b", "c"]时，cap(path)的值为 4, len(path)的值为 3，每一次 append 所返回的 newPath，其实本质上是在切片中进行更改，newPath 和path在底层指向的是同一片空间，只不过 path 的长度是 3，而 newPath 长度是 4，每一次 append(path, k) 之后，修改的都是内存空间中的同一个位置。画图举例

因此正确的操作是将 newPath := append(path, k) 改为

newPath := make([]string, len(path)
copy(newPath, path)
newPath := append(newPath, k)

需要分配给 newPath 一片新的空间，防止 append 在同一空间内不断更改。