在JavaScript中扩散数组时，当数组/对象路径被*移动*时，如何实现检查和忽略？

我见过，但上面写着：

对数组的更改被简单地记录下来。我们最关心的是结构的形状；因此，我们不需要花时间来确定对象是否从阵列中的一个插槽移动到另一个插槽

所以在那里不起作用

您将如何实现这一点？这似乎很难。是否可以构建这些现有库中的一个来忽略数组移动？或者，您将如何直接从头开始实施它

我的用例是，我希望跟踪对JSON对象所做的所有更改，以便人们能够为他们所做的每一次更改获得积分/报酬。但是如果人们只是删除一个数组路径，然后在UI的另一个位置重新添加它，我不想给分数，那将是欺骗：）

我开始尝试将路径展平，然后在路径上使用正则表达式，但这似乎不起作用：

const flat = require('flat')

const compute = (_a, _b) => {
  const a = flat(_a)
  const b = flat(_b)

  let r_a = []
  for (let k_a in a) {
    r_a.push([
      k_a,
      new RegExp(`^` + k_a.replace(/\./g, '\\.').replace(/\d+/g, '\\d+') + `$`)
    ])
  }

  let r_b = []
  for (let k_b in b) {
    r_b.push([
      k_b,
      new RegExp(`^` + k_b.replace(/\./g, '\\.').replace(/\d+/g, '\\d+') + `$`)
    ])
  }

  let diff = []
  for (let i = 0, n = r_a.length; i < n; i++) {
    let [k_a, r_a_i] = r_a[i]
    let matches = false
    k_b_loop:
    for (let k_b in b) {
      if (r_a_i.test(k_b) && a[k_a] === b[k_b]) {
        matches = true
        break k_b_loop
      }
    }
    if (!matches) {
      diff.push({
        type: 'remove',
        path: k_a
      })
    }
  }

  for (let i = 0, n = r_b.length; i < n; i++) {
    let [k_b, r_b_i] = r_b[i]
    let matches = false
    k_a_loop:
    for (let k_a in a) {
      if (r_b_i.test(k_a) && b[k_b] === a[k_a]) {
        matches = true
        break k_a_loop
      }
    }
    if (!matches) {
      diff.push({
        type: 'create',
        path: k_b
      })
    }
  }

  return diff
}

const test1 = () => {
  const a = { 
    a: [
      { a: 1, b: 2 },
      { a: 1, b: 3 }
    ],
    b: 1,
    c: 2
  }
  const b = { 
    a: [
      { a: 1, b: 3 },
      { a: 1, b: 1 },
      { a: 1, b: 4 }
    ],
    c: 3
  }
  const diff = computeDiff(a, b)
  console.log(diff)
}

test1()

const flat=require（'flat'））
常数计算=（_a，_b）=>{
常数a=平坦（_a）
常数b=平坦（_b）
设r_a=[]
for（让k_a在a中）{
推([
库阿，
新的RegExp（`^`+k\'a.replace（/\./g，'\\.'）。replace（/\d+/g，'\\d++'）+`$`）
])
}
设r_b=[]
for（让k_b在b中）{
推([
库布，
新的RegExp（`^`+k\'b.replace（/\./g，'\\.'）。replace（/\d+/g，'\\d++'）+`$`）
])
}
设diff=[]
for（设i=0，n=r_a.length；i{
常数a={
a:[
{a:1，b:2}，
{a:1，b:3}
],
b:1，
c:2
}
常数b={
a:[
{a:1，b:3}，
{a:1，b:1}，
{a:1，b:4}
],
c:3
}
const diff=computeDiff（a，b）
console.log（差异）
}
test1（）