JavaScript循环条件判断优化：如何避免重复判断与代码冗余？

嘿，这个场景我太熟悉了——既要消除循环里的重复条件判断，又不想复制粘贴一大段循环代码导致冗余，确实有几个挺优雅的解决方案，我给你捋捋：

方案1：提取循环逻辑到独立函数，动态选择处理逻辑 #

把循环里固定的测试逻辑和可变的（是否执行test2）拆分开，根据b的状态生成最终的处理函数，这样循环只需要写一次：

function foo(b) {
  var words = ["Lorem", "ipsum", "dolor", "sit", "amet"];
  
  // 封装固定的测试逻辑
  function baseProcess(word) {
    /a/.test(word); // test 1
    /c/.test(word); // test 3 （原代码里的`swordstr`应该是笔误，我这里修正为`word`）
  }
  
  // 根据b决定是否追加test2的逻辑
  const finalProcess = b 
    ? (word) => {
        baseProcess(word);
        /b/.test(word); // test 2
      }
    : baseProcess;
  
  // 仅执行一次循环，调用对应的处理函数
  for (const word of words) { // 推荐用for...of遍历数组，比for...in更安全
    finalProcess(word);
  }
}

这个思路的好处是逻辑拆分清晰，后续如果要新增更多条件分支，只需要扩展finalProcess的判断即可，完全不会增加循环代码的冗余。

方案2：用测试集合动态扩展，统一执行 #

如果你的测试都是正则匹配这类同构逻辑，可以把要执行的测试放到数组里，根据b动态添加测试项，最后循环里统一执行所有测试：

function foo(b) {
  var words = ["Lorem", "ipsum", "dolor", "sit", "amet"];
  
  // 初始化基础测试集合
  const tests = [/a/, /c/];
  // 根据b追加test2的正则
  if (b) {
    tests.push(/b/);
  }
  
  // 遍历每个单词，执行所有测试
  for (const word of words) {
    tests.forEach(test => test.test(word));
  }
}

这个方案代码最简洁，把条件判断的成本从循环内转移到了数组初始化阶段，只做一次判断，而且逻辑非常直观。

方案3：用闭包封装状态（进阶版） #

如果你的逻辑更复杂，可以用闭包提前保存b的状态，生成一个已经确定执行逻辑的处理器函数，循环里直接调用即可：

// 提前封装处理器生成逻辑
function createWordProcessor(shouldRunTest2) {
  return function(word) {
    /a/.test(word); // test1
    if (shouldRunTest2) {
      /b/.test(word); // test2
    }
    /c/.test(word); // test3
  }
}

function foo(b) {
  var words = ["Lorem", "ipsum", "dolor", "sit", "amet"];
  // 根据b生成对应的处理器（仅判断一次b）
  const processWord = createWordProcessor(b);
  
  // 循环执行处理逻辑
  for (const word of words) {
    processWord(word);
  }
}

闭包会记住shouldRunTest2的状态，所以循环里调用processWord时不需要再做任何判断，完美平衡了性能和代码复用性。

另外提个小建议：原代码里用for...in遍历数组不太推荐，因为它会遍历数组的所有可枚举属性（包括原型链上的），处理数组优先用for...of或普通for循环，避免意外问题。

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