基于ID键从数组中更新或从数组中删除的对象数组的JavaScript递归函数

Question

我试图在下面的一系列对象上创建两个（2）递归功能。我认为这两个功能是“相似的”，但它们做了两种不同的事情。

函数1应该更新对象 - 可能是“找到”对象中的每个字段并返回对象的“新”数组，因此该功能需要通过.id

code 2需要通过.id识别适当的对象，但要删除该对象，然后再次返回对象的“新”数组。

我已经尝试了多种方法（在对象的数组以下） - 但是，我无济于事，我无法让新对象返回。

要注意即使每个对象都有变化/不同的键，总会有一个.id键 -

[
    {
        "type":"section",
        "name":"Section 1",
        "hassection":[      
            {
                "type":"section",
                "id":1,
                "name":"Section 1 child section 1",
                "hasMenuItem":
                    [
                        {
                            "type":"item",
                            "id":2,
                            "name":"Item 1",
                            "prices":
                            {
                                "type":"price",
                                "price":"15.95"
                            },
                            "description":"Blah Blah..."
                        },{
                            "type":"item",
                            "id":3,"name":
                            "Item 2",
                            "prices":[
                                {
                                    "type":"price",
                                    "price":"24.95"
                                },{
                                    "type":"price",
                                    "price":"13.95"
                                }
                            ],
                            "description":"Blah Blah..."
                        }
                ]
            },{
                "type":"section",
                "id":4,
                "name":"Section 1 child section 2",
                "hasitem":[
                    {
                        "type":"item",
                        "name":"Item 3",
                        "prices":
                        {
                            "type":"price","price":"14.50"
                        },
                        "description":"Blah Blah..."
                    },{
                        "type":"item",
                        "id":5,
                        "name":"Item 4",
                        "prices":
                        {
                            "type":"price",
                            "price":"14.50"
                        },
                        "description":"Blah Blah..."
                    }
                ]
            },
        ]},{
            "type":"section",
            "name":"Section 2",
            "hassection":[      
                {
                    "type":"section",
                    "id":6,
                    "name":"Section 2 child section 1",
                    "hasitem":[
                        {
                            "type":"item",
                            "id":7,
                            "name":"Item 5",
                            "prices":
                            {
                                "type":"price",
                                "price":"15.95"
                            },
                            "description":"Blah Blah..."
                        },
                        {
                            "type":"item",
                            "id":8,
                            "name":"Item 6",
                            "prices":
                            {
                                "type":"price",
                                "price":"13.95"
                            },
                            "description":"Blah Blah..."
                        }
                    ]
            }
        ]}
    ]

我的更新函数

function updateNestedObj(obj,updates) {
    const updateToApply = updates.find(upd => upd.id === obj.id);
    if (updateToApply) {
        // UPDATE THE OBJ
    }
    
    for(let k in obj) {
        if (typeof(obj[k]) === 'object') {
            // LOOP THROUGH THE OBJECT
            updateNestedObj(obj[k], updates);
        }
    }
    return updateToApply
}

我的删除函数，

function deleteNestedObj(obj, updates) {
    const updateToApply = updates.find(upd => upd.id === obj.id);
    if (updateToApply) {
        delete upd;       
    }    
    for(let k in obj) {
        if (typeof(obj[k]) === 'object') {
            deleteNestedObj(obj[k], updates);
        }
    }
}

我只是无法理解如何“工作”他们” - 事先感谢，任何帮助都非常感谢。

Answer 1

generics

让我们从不变的更新（t，func）开始，该采用任何类型的值，t和可呼出的更新器功能，<代码> func 。 func根据呼叫者的指定返回值转换t。如果没有返回值，即undefined，那么update will remove 该值从树中 -

function update(t, func) {
  switch (t?.constructor) {
    case Object:
      return Object.entries(t).reduce((r, [k, v]) => {
        const newValue = update(func(v), func)
        if (newValue !== undefined) r[k] = newValue
        return r
      }, {})
    case Array:
      return t.flatMap(v => {
        const newValue = update(func(v), func)
        return newValue === undefined ? [] : [newValue]
      })
    default:
      return t
  }
}

不成熟的remove（t，func） 的专业化

function remove(t, func) {
  return update(t, v => Boolean(func(v)) ? undefined : v)
}

可以定义为更新 - 特殊表格

该功能可以进一步专业化以满足您的特定需求。 updateWithObj（t，obj）将递归更新t其中一个节点的id匹配obj.id obj.id -

function updateWithObj(t, obj) {
  return update(t, v => v.id == obj.id ? {...v, ...obj} : v)
}

同样。 > removewithObj（t，obj）递归从t中删除，其中节点的id匹配obj.id -

function removeWithObj(t, obj) {
  return remove(t, v => v.id == obj.id)
}

示例< /strong>

让我们创建一些示例数据。对于它的价值，Update不在乎它是元素数组，[...]或一个对象，{...} -

const data = [
  {id: 1, data: 50 },
  {id: 2, data: {id: 3, data: "foo"}},
  {id: 4, data: [{id: 5, data: 3.141}, {id: 6, data: {id: 7, data: "bar"}}]}
]

我们将从obj.id == 1上的简单更新开始。请注意，现有的数据属性保留在触觉中，并添加了新的ok属性。所有其他节点保持不变 -

console.log(updateWithObj(data, {id: 1, ok: "✅"}))

[

  {

    "id": 1,

    "data": 50,  //