如何在嵌套数组中查找指定元素（如i=5）及其父对象？

这是个挺常见的嵌套数据结构查找需求，我来分享几个实用的实现思路，既能精准定位到目标元素，还能拿到它所在的父对象（以及所在的数组）引用：

方法一：递归遍历法（适合层级不深的场景） #

递归是处理嵌套结构最直观的方式，核心思路是遍历每一个节点，同时追踪当前节点的父对象和所在数组，一旦找到符合条件的元素就立即返回结果。

以JavaScript为例，实现代码如下：

function findTargetWithParent(data, targetKey = 'i', targetValue = 5) {
  // 定义递归辅助函数
  function traverse(current, parentObj, parentArray) {
    // 如果当前是数组，遍历每个元素继续递归
    if (Array.isArray(current)) {
      for (let i = 0; i < current.length; i++) {
        const result = traverse(current[i], parentObj || current, current);
        if (result) return result;
      }
    } 
    // 如果当前是对象，检查是否匹配目标
    else if (typeof current === 'object' && current !== null) {
      if (current[targetKey] === targetValue) {
        return {
          target: current,
          parent: parentObj,
          parentArray: parentArray
        };
      }
      // 遍历对象的所有属性，继续递归嵌套结构
      for (const key in current) {
        if (current.hasOwnProperty(key)) {
          const result = traverse(current[key], current, null);
          if (result) return result;
        }
      }
    }
    return null;
  }

  return traverse(data, null, null);
}

使用的时候直接传入你的嵌套数据结构就行，返回的对象里包含了目标元素target、父对象parent，以及目标所在的数组parentArray。如果没找到匹配项，会返回null。

方法二：迭代遍历法（适合深层嵌套场景） #

如果你的数据结构层级非常深，递归可能会触发栈溢出问题，这时候用迭代法（基于栈/队列）更稳妥。我们把每个节点的上下文（当前元素、父对象、父数组）存入栈中，循环处理每个节点：

function findTargetWithParentIterative(data, targetKey = 'i', targetValue = 5) {
  // 初始化栈，存入根节点的上下文
  const stack = [{ current: data, parentObj: null, parentArray: null }];

  while (stack.length > 0) {
    const { current, parentObj, parentArray } = stack.pop();

    if (Array.isArray(current)) {
      // 数组元素入栈，父对象是当前数组，父数组也是当前数组
      for (let i = current.length - 1; i >= 0; i--) {
        stack.push({
          current: current[i],
          parentObj: current,
          parentArray: current
        });
      }
    } else if (typeof current === 'object' && current !== null) {
      // 检查当前对象是否匹配目标
      if (current[targetKey] === targetValue) {
        return {
          target: current,
          parent: parentObj,
          parentArray: parentArray
        };
      }
      // 对象的属性值入栈，父对象是当前对象
      for (const key in current) {
        if (current.hasOwnProperty(key)) {
          stack.push({
            current: current[key],
            parentObj: current,
            parentArray: null
          });
        }
      }
    }
  }
  return null;
}

这个方法用栈来模拟递归过程，避免了递归深度限制，处理超大嵌套结构更安全。

额外说明 #

• 如果你的数据中有多个匹配i=5的对象，上面的代码会返回第一个找到的结果。如果需要收集所有匹配项，只需要把返回逻辑改成将结果存入数组，遍历完所有节点后返回数组即可。
• 可以根据你的编程语言调整代码逻辑，核心思路都是遍历+上下文追踪，不管是JS、Python还是Java，这个逻辑都是通用的。

内容的提问来源于stack exchange，提问作者Ian Warburton