如何优化动态数据字符串校验更新的递归逻辑，减少递归深度？

我需要对结构动态变化的数据对象中所有对象或数组内的字符串值执行校验、更新与转义操作。目前的递归代码可以正常运行，但想知道是否能对其进行优化或减少递归深度。以下是我的代码实现：

let data = {
  "data": "general",
  "another" : ["fbdfdfdfdfdfdfdfdf", "somestring2"],
  "MyStringArray" : ["valid_type.pathdir", "/pathdir/desdss"],
  "html_data":  [
      {
      "data": [
          {
            "item_title": "Server Version:",
          },
          ["fbdfdfdfdfdfdfdfdf", "somestring2"],
          {
            "value_title": "2.0.1"
          }
        ]
      },
      {
      "head_title": "Info app",
      "data": [
          {
            "value_title": "1.0.1"
          },
          {
            "item_title": "javascript Version:",
          }
        ]
      }
  ]
};
    
let counter = 0
let limit_recursion = 150

    
function funct(object) {

  if ( counter > limit_recursion ) {
    throw new Error("limit exceeded, maximum recursion allowed is " + limit_recursion );
  }
  

  for ( let key in object ) {

    if (typeof object[key] === "string") {
      object[key] = validate_escape(object[key]);
    }
    else if ( _has_array_to_validate_get_string(object[key]) ) { // ["valid_type.pathdir", "/pathdir/desdss"],

      object[key][1] = validate_escape(object[key][0], object[key][1]);

    }
    else if ( Array.isArray(object[key]) && object[key].every(item => typeof item === "string")  ) {

      object[key].forEach((value, index) => {
        object[key][index] = validate_escape(value);
      });

    }
    else if ( Array.isArray(object[key]) && object[key].every(    item => typeof item === "object" && !Array.isArray(item)     )  ) {

      object[key].forEach((value) => {
        funct(value);
      });

    }
    else if (typeof object[key] === 'object' && !Array.isArray(object[key]) ) {

      funct(object[key])

    }
    else if ( Array.isArray(object[key] ) ) {

      funct(object[key])

    }

      counter++;
  }

  return object;

}

关于_has_array_to_validate_get_string函数：用于识别需特殊校验的数组结构；关于validate_escape：用于执行校验、更新与转义的内部工具函数。

function _has_array_to_validate_get_string(array) {
  return Array.isArray(array) && array.length === 2 && typeof array[0] === "string" && array[0].includes('valid_type');
}

function validate_escape(var1, var2) {
  return var1 + var2;
}

核心优化方向 #

1. 用迭代替代递归：彻底消除递归深度限制，避免嵌套过深触发报错
2. 简化条件分支：合并重复的数组/对象判断逻辑，减少冗余代码
3. 修复计数器逻辑：原计数器的递增逻辑错误，迭代方案无需依赖计数器，直接规避问题
4. 优先处理特殊数组：提前判断特殊数组结构，避免被通用数组逻辑覆盖

优化后的完整代码 #

let data = {
  "data": "general",
  "another" : ["fbdfdfdfdfdfdfdfdf", "somestring2"],
  "MyStringArray" : ["valid_type.pathdir", "/pathdir/desdss"],
  "html_data":  [
      {
      "data": [
          {
            "item_title": "Server Version:",
          },
          ["fbdfdfdfdfdfdfdfdf", "somestring2"],
          {
            "value_title": "2.0.1"
          }
        ]
      },
      {
      "head_title": "Info app",
      "data": [
          {
            "value_title": "1.0.1"
          },
          {
            "item_title": "javascript Version:",
          }
        ]
      }
  ]
};

function _has_array_to_validate_get_string(array) {
  return Array.isArray(array) && array.length === 2 && typeof array[0] === "string" && array[0].includes('valid_type');
}

function validate_escape(var1, var2) {
  return var1 + var2;
}

function processData(obj) {
  // 栈存储待处理节点，实现深度优先遍历（和原递归遍历顺序一致）
  const stack = [{ target: obj }];

  while (stack.length > 0) {
    const { target } = stack.pop();

    if (typeof target === "object" && target !== null) {
      if (Array.isArray(target)) {
        // 优先处理特殊数组
        if (_has_array_to_validate_get_string(target)) {
          target[1] = validate_escape(target[0], target[1]);
          continue;
        }
        // 逆序压栈保证遍历顺序和原递归一致
        for (let i = target.length - 1; i >= 0; i--) {
          const item = target[i];
          if (typeof item === "string") {
            target[i] = validate_escape(item);
          } else if (typeof item === "object" && item !== null) {
            stack.push({ target: item });
          }
        }
      } else {
        // 遍历普通对象的属性
        for (const key in target) {
          if (Object.prototype.hasOwnProperty.call(target, key)) {
            const value = target[key];
            if (typeof value === "string") {
              target[key] = validate_escape(value);
            } else if (_has_array_to_validate_get_string(value)) {
              value[1] = validate_escape(value[0], value[1]);
            } else if (typeof value === "object" && value !== null) {
              stack.push({ target: value });
            }
          }
        }
      }
    }
  }
  return obj;
}

// 调用示例
processData(data);
console.log(data);

优化效果说明 #

• 移除了递归逻辑，没有递归深度限制，适配任意嵌套深度的数据结构
• 合并了原代码中分散的数组判断逻辑，代码结构更清晰，维护成本降低
• 修复了原计数器每次循环递增的错误，无需设置递归次数上限
• 遍历顺序和原递归保持一致，不会改变数据处理的先后顺序

内容的提问来源于stack exchange，提问作者The nothing