如何创建或从输入转换为输出优化方式？

Question

我正在尝试使用下面的代码基于父子关系在对象数组中创建路径并获取超出最大调用堆栈大小的错误

var input = [{
        clientArrngmntId: 12,
        level: 1,
        hasChild: true,
        parentId: 0,
        idx: 0,
    },
    {
        clientArrngmntId: 13,
        level: 2,
        hasChild: true,
        parentId: 12,
        idx: 2,
    },
    {
        clientArrngmntId: 14,
        level: 3,
        hasChild: false,
        parentId: 13,
        idx: 3,
    },
    {
        clientArrngmntId: 15,
        level: 2,
        hasChild: false,
        parentId: 12,
        idx: 4,
    },
    {
        clientArrngmntId: 16,
        level: 1,
        hasChild: false,
        parentId: 0,
        idx: 5,
    }]
    
    var output = [{
        clientArrngmntId: 12,
        level: 1,
        hasChild: true,
        parentId: 0,
        path:[12],
        idx: 0,
    },
    {
        clientArrngmntId: 13,
        level: 2,
        hasChild: true,
        parentId: 12,
        path: [12,13],
        idx: 2,
    },
    {
        clientArrngmntId: 14,
        level: 3,
        hasChild: false,
        parentId: 13,
        path: [12,13,14],
        idx: 3,
    },
    {
        clientArrngmntId: 15,
        level: 2,
        hasChild: false,
        parentId: 12,
        path: [12,15],
        idx: 4,
    },
    {
        clientArrngmntId: 16,
        level: 1,
        hasChild: false,
        parentId: 0,
        path: [16]
        idx: 5,
    }]


const processDataAlt = data => {
    const flattenedData = []
    const flattenRowRecursive = (row, parentPath) => {
        const dataPath = [ ...parentPath, row.clientArrngmntId ]
        flattenedData.push({
            ...row,
            dataPath,
        })
        if (row.hasChild && !flattenedData.includes(row.clientArrngmntId)) {
            flattenRowRecursive(row, dataPath)
        }
    }
    data.forEach(row => flattenRowRecursive(row, []))
    return flattenedData
}

Answer 1

要基于父子关系在对象数组中创建路径而不导致调用堆栈大小超出错误，可以使用迭代方法而不是递归方法。

以下示例说明了如何使用循环为输入数组中的每个对象构建路径来实现此目的：

var input = [{
    clientArrngmntId: 12,
    level: 1,
    hasChild: true,
    parentId: 0,
    idx: 0,
},
{
    clientArrngmntId: 13,
    level: 2,
    hasChild: true,
    parentId: 12,
    idx: 2,
},
{
    clientArrngmntId: 14,
    level: 3,
    hasChild: false,
    parentId: 13,
    idx: 3,
},
{
    clientArrngmntId: 15,
    level: 2,
    hasChild: false,
    parentId: 12,
    idx: 4,
},
{
    clientArrngmntId: 16,
    level: 1,
    hasChild: false,
    parentId: 0,
    idx: 5,
}];

// Create a map to store the paths based on clientArrngmntId
const pathMap = {};

// Iterate over each object in the input array
input.forEach(obj => {
    const path = [obj.clientArrngmntId]; // Initialize the path with the current clientArrngmntId
    let parentId = obj.parentId;

    // Traverse the parent hierarchy to build the complete path
    while (parentId !== 0) {
        const parentObj = input.find(parent => parent.clientArrngmntId === parentId);
        path.unshift(parentObj.clientArrngmntId);
        parentId = parentObj.parentId;
    }

    pathMap[obj.clientArrngmntId] = path; // Store the path in the map
});

console.log(pathMap); // Output the paths for each object