在嵌套JavaScript对象中基于泛化路径模式查找并收集数据

const obj = {
    a: [
        { b: { c: [{ value: 'A' }] } },
        { b: { c: [{ foo: 1 }, { value: 'B' }] } },
        {
            b: {
                c: [{
                    value: 'C',
                    b: {
                        c:
                            [{ value: 'D' }]
                    }
                }]
            }
        }
    ],
    a1: [
        { b: { c: [{ value: 'A1' }] } },
        { b: { c: [{ foo: 1 }, { value: 'B1' }] } },
        {
            b: {
                c: [{
                    value: 'C1',
                    b: {
                        c:
                            [{ value: 'D1' }]
                    }
                }]
            }
        }
    ],
};

/**
 * 递归查找目标字符串的泛化路径。
 * @param {object|Array} currentObj 当前要搜索的对象或数组。
 * @param {string} targetStr 目标字符串。
 * @param {Array<string|number>} currentPath 当前累积的路径片段。
 * @param {boolean} isParentArray 标识当前 currentObj 是否为父级数组的元素。
 * @returns {Array<string|number>|undefined} 找到的泛化路径数组，如果未找到则返回 undefined。
 */
function findPath(currentObj, targetStr, currentPath = [], isParentArray = false) {
    // 遍历当前对象的键值对
    for (const [key, val] of Object.entries(currentObj)) {
        // 构建当前节点的路径。如果父级是数组，则使用0作为索引占位符；否则使用键名。
        const pathSegment = isParentArray ? 0 : key;
        const newPath = currentPath.concat(pathSegment);

        // 检查值是否为对象或数组，如果是，则继续递归搜索
        const isChildArray = Array.isArray(val);
        const isChildObject = typeof val === 'object' && val !== null && !isChildArray;

        if (isChildArray || isChildObject) {
            const foundPath = findPath(val, targetStr, newPath, isChildArray);
            if (foundPath) {
                return foundPath; // 如果在子结构中找到，则直接返回
            }
        } else if (typeof val === 'string' && val.includes(targetStr)) {
            // 如果当前值是字符串且包含目标字符串，则返回当前构建的路径
            return newPath;
        }
    }
    return undefined; // 未找到
}

/**
 * 依据泛化路径模式收集对象中的值。
 * @param {object|Array} currentObj 当前要搜索的对象或数组。
 * @param {Array<string|number>} remainingPath 待匹配的剩余路径片段。
 * @param {Array<any>} collected 收集到的值数组。
 */
function collect(currentObj, remainingPath, collected) {
    // 如果路径已匹配完，且当前对象是一个有效值，则将其添加到收集结果中
    if (remainingPath.length === 0) {
        // 确保当前obj是实际的值而不是一个中间对象/数组
        if (typeof currentObj !== 'object' || currentObj === null) {
             collected.push(currentObj);
        } else if ('value' in currentObj) { // 假设目标值在一个名为'value'的字段中
             collected.push(currentObj.value);
        }
        return;
    }

    const nextPathSegment = remainingPath.shift(); // 取出路径的下一个片段

    // 如果下一个路径片段是0（数组索引通配符）且当前对象是数组
    if (nextPathSegment === 0 && Array.isArray(currentObj)) {
        for (const item of currentObj) {
            // 对数组中的每个元素，都尝试匹配剩余路径
            collect(item, remainingPath.slice(), collected); // 使用 slice() 复制路径，避免相互影响
        }
        return;
    }

    // 如果下一个路径片段是键名且当前对象是对象，并且该键存在
    if (typeof nextPathSegment === 'string' && typeof currentObj === 'object' && currentObj !== null && nextPathSegment in currentObj) {
        collect(currentObj[nextPathSegment], remainingPath, collected);
        return;
    }
    // 如果路径不匹配，或者键不存在，则停止当前分支的收集
}

// 示例数据 (同上)
const obj = {
    a: [
        { b: { c: [{ value: 'A' }] } },
        { b: { c: [{ foo: 1 }, { value: 'B' }] } },
        {
            b: {
                c: [{
                    value: 'C',
                    b: {
                        c:
                            [{ value: 'D' }]
                    }
                }]
            }
        }
    ],
    a1: [
        { b: { c: [{ value: 'A1' }] } },
        { b: { c: [{ foo: 1 }, { value: 'B1' }] } },
        {
            b: {
                c: [{
                    value: 'C1',
                    b: {
                        c:
                            [{ value: 'D1' }]
                    }
                }]
            }
        }
    ],
};

const targetString = 'A';

// 1. 查找目标字符串的泛化路径
const generalizedPath = findPath(obj, targetString);

if (!generalizedPath) {
    console.error(new Error(`目标字符串 "${targetString}" 未找到。`));
} else {
    console.log("找到的泛化路径模式:", generalizedPath); // 例如: ['a', 0, 'b', 'c', 0, 'value']

    // 2. 依据泛化路径模式收集所有匹配的值
    const collectedValues = [];
    collect(obj, generalizedPath.slice(), collectedValues); // 复制路径，避免 collect 函数修改原始路径

    console.log("收集到的值:", collectedValues); // 预期输出: ['A', 'B', 'C']
}