将生成树状数组叶子路径的JS代码适配至JavaScript 1.7版本

function getLeafPaths(node, path) {
  // 处理默认参数，替代ES6默认参数与空值合并逻辑
  var currentPath;
  if (typeof path === 'undefined' || path === null) {
    currentPath = [];
  } else {
    // 复制路径数组，避免递归中修改原数组（替代解构赋值 [...path]）
    currentPath = [];
    for (var i = 0; i < path.length; i++) {
      currentPath.push(path[i]);
    }
  }

  // 兜底处理节点值，避免拼接时出现NaN
  var nodeValue = typeof node.value !== 'undefined' ? node.value : '';
  currentPath.push(nodeValue);

  // 判断是否为叶子节点
  var isLeaf = true;
  if (typeof node.children !== 'undefined' && node.children instanceof Array) {
    if (node.children.length > 0) {
      isLeaf = false;
    }
  }

  if (isLeaf) {
    return [currentPath.join('->')];
  } else {
    var result = [];
    // 遍历子节点并合并结果（替代flatMap）
    for (var j = 0; j < node.children.length; j++) {
      var childPaths = getLeafPaths(node.children[j], currentPath);
      for (var k = 0; k < childPaths.length; k++) {
        result.push(childPaths[k]);
      }
    }
    return result;
  }
}

// 示例调用
var tree = {
  value: 'root',
  children: [
    { value: 'a', children: [{ value: 'a1' }, { value: 'a2' }] },
    { value: 'b', children: [{ value: 'b1', children: [{ value: 'b1-1' }] }] },
    { value: 'c' }
  ]
};

console.log(getLeafPaths(tree));
// 输出：["root->a->a1", "root->a->a2", "root->b->b1->b1-1", "root->c"]

NaN问题的核心原因及修正 #

你之前输出出现NaN，主要是两个点：

1. 未处理节点值为空的情况：当节点没有value属性时，直接拼接undefined与字符串会得到NaN，代码中通过nodeValue = typeof node.value !== 'undefined' ? node.value : ''做了兜底。
2. 路径数组传递错误：如果直接传递原路径数组而非复制，递归过程中会修改同一个数组，导致路径混乱并混入异常值，代码中通过循环复制数组解决了这个问题。

递归在树深度极大时可能触发栈溢出，迭代式用栈模拟递归流程，更适配大型树结构，同样兼容JS1.7：

function getLeafPathsIterative(root) {
  var result = [];
  // 栈元素存储节点与当前路径数组
  var stack = [];
  stack.push({ node: root, path: [] });

  while (stack.length > 0) {
    var stackItem = stack.pop();
    var node = stackItem.node;
    var currentPath = stackItem.path;

    // 复制路径并添加当前节点值
    var newPath = [];
    for (var i = 0; i < currentPath.length; i++) {
      newPath.push(currentPath[i]);
    }
    var nodeValue = typeof node.value !== 'undefined' ? node.value : '';
    newPath.push(nodeValue);

    // 判断是否为叶子节点
    var isLeaf = true;
    if (typeof node.children !== 'undefined' && node.children instanceof Array && node.children.length > 0) {
      isLeaf = false;
      // 栈是后进先出，倒序入栈保证遍历顺序与递归一致
      for (var j = node.children.length - 1; j >= 0; j--) {
        stack.push({ node: node.children[j], path: newPath });
      }
    } else {
      result.push(newPath.join('->'));
    }
  }

  return result;
}

// 示例调用
console.log(getLeafPathsIterative(tree));
// 输出：["root->c", "root->b->b1->b1-1", "root->a->a2", "root->a->a1"]
// 若需要与递归一致的顺序，可在最后执行 result.reverse()

内容的提问来源于stack exchange，提问作者Imran Al Rashid