后台有个批量审核页面,勾选多条记录后循环处理,代码用了 for...in 遍历选中的数组。上线后偶发提交多出来几条莫名其妙的记录,ID 是一串数字拼成的字符串。查了半天发现:某些老库往 Array.prototype 上挂了一个扩展方法,for...in 连这个方法名也一起遍历了。

另一个更常见的:循环里给每条数据发请求,写了 list.forEach(async (item) => { await save(item); }),以为会一条条处理完再往下走,结果后面的代码立刻执行了,数据还没保存完。

这篇讲什么:条件和循环本身不难,难在选错写法之后不报错、只是结果不对。这篇把 if、switch、四种循环的适用场景和各自的坑讲清楚。读完你能做到:遍历数组和对象时选对工具;知道 forEach 为什么不能 break;写出循环处理异步任务时顺序符合预期的代码。

条件分支:先处理异常,再走正常路

业务代码里最常见的分支不是「二选一」,而是「先校验一堆前提」。新手喜欢层层嵌套:

function submit(form) {
  if (form.name) {
    if (form.phone) {
      if (form.agree) {
        // 真正的提交逻辑,被推到了第四层
        doSubmit(form);
      } else {
        alert("请先同意协议");
      }
    } else {
      alert("请填写手机号");
    }
  } else {
    alert("请填写姓名");
  }
}

这种写法能跑,但读起来要在大脑里维护一个「当前在哪一层」的状态。改成守卫语句,把不合法的情况提前返回,主干逻辑就摊平了:

function submit(form) {
  if (!form.name) return alert("请填写姓名");
  if (!form.phone) return alert("请填写手机号");
  if (!form.agree) return alert("请先同意协议");

  doSubmit(form);
}

这不只是为了好看。嵌套深的代码在加条件时特别容易改错层,加一个 else 就跑到别的分支去了;守卫语句是线性的,加一条就在上面加一行。

守卫语句里 return 的值要留意。return alert("请填写姓名") 这种写法,函数返回值是 alert 的返回值(通常是 undefined),调用方拿不到「为什么失败」。上层要区分「用户取消」和「校验失败」时,返回结构化结果更稳:

function validate(form) {
  if (!form.name) return { ok: false, field: "name" };
  if (!form.phone) return { ok: false, field: "phone" };
  if (!form.agree) return { ok: false, field: "agree" };
  return { ok: true };
}

另一个常见错误是条件里写赋值:if (status = "paid") 不会报错,字符串非空永远为真,先把 status 改成了 "paid",再走进分支。团队里开 no-cond-assign,能省很多排查时间。

另一个经验:能用一个映射表代替的分支,就别写一长串 else if。

// 一般
if (status === "pending")   label = "待付款";
else if (status === "paid") label = "已付款";
else if (status === "closed") label = "已关闭";

// 状态多了以后
const STATUS_LABEL = {
  pending: "待付款",
  paid: "已付款",
  closed: "已关闭"
};
const label = STATUS_LABEL[status] ?? "未知状态";

好处是新增状态只改一处数据,不用动逻辑;坏处是映射表适合「一对一翻译」,一旦每个分支要做不同的事(发不同请求、显示不同弹窗),还是得用分支。

switch:两个必须知道的规则

switch 适合「一个值分几种情况,每种情况做一件不同的事」。它有两个规则,不知道就会写出 bug:

比较方式是严格相等

case "1" 匹配不到数字 1。接口返回状态码是数字还是字符串,得先确认。这一点比 if (x == 1) 安全,但也意味着类型不对时什么都不匹配,静默走到 default。

忘了 break 会「贯穿」

匹配到某个 case 后,如果不写 break,会继续执行下一个 case 的代码,直到遇到 break 或结束。这不是 bug,是语言特性,但十次见到都是漏写。

function handleStatus(code) {
  switch (code) {
    case 1:
      console.log("待付款");
      // 漏了 break
    case 2:
      console.log("已付款");
      break;
    default:
      console.log("未知");
  }
}
handleStatus(1);
// 实际输出:待付款 / 已付款
// 期望只输出:待付款

偶尔有人故意利用贯穿来合并几个分支,比如 case 1: case 2: case 3: 共用一段代码,这种写法是合理的。但如果是共用逻辑,把几个 case 叠在一起写,别让代码顺序贯穿下去,读的人更容易看懂。

如果 case 里要声明变量,建议用花括号把这一段包起来,避免几个 case 共享同一个块作用域:

switch (code) {
  case 1: {
    const label = "待付款";
    console.log(label);
    break;
  }
  case 2:
    console.log("已付款");
    break;
  default:
    console.log("未知");
}

函数里用 switch 时,用 return 代替 break 更直接,少一层跳出逻辑;default 不要省,未知状态至少能留条日志。

四种循环,别只背语法要看用途

JavaScript 里常用的循环有四种,它们的区别不在语法长短,而在「能遍历什么」「能不能中途退出」「需不需要等异步」。

写法适合遍历能 break / continue注意
for (let i = 0; i < n; i++)数组,需要下标或倒序能最灵活,也最容易写错边界
for...of数组、字符串、Map、Set 等可迭代对象能直接拿值,推荐做主力
for...in对象的键能用在数组上会拿到字符串下标,还会碰到原型属性
while / do...while次数不确定,靠条件停能条件写错容易死循环

日常最稳的选择:数组用 for...of,对象用 for...in 配合 hasOwnProperty 或者 Object.keys,需要下标就用经典 for。

for...of 不是万能的:普通对象没有迭代器,直接遍历会抛 TypeError: obj is not iterable,对象还是得用 Object.keys 或 Object.entries。数组想要下标可以写 list.entries():

for (const [index, value] of list.entries()) {
  console.log(index, value);
}
// 0 "苹果"
// 1 "香蕉"

另外,for...of 会遍历稀疏数组的空位并给出 undefined,forEach 会跳过空位。同一份数据两种写法结果不一样,遇到这种数据最好在入口就清掉。

for...in 用在数组上,会出什么事

先看一段能直接跑的代码:

const list = ["苹果", "香蕉", "橙子"];
for (const key in list) {
  console.log(key, typeof key);
}
// 0 string
// 1 string
// 2 string

键是字符串。于是 key + 1 不是 1,而是 "01";list[key] 能取到值,所以大部分时候它「看起来能用」,直到你拿这个键去算数。更麻烦的是原型上的属性:

Array.prototype.last = function () {
  return this[this.length - 1];
};

const list = ["a", "b"];
for (const key in list) {
  console.log(key);
}
// 0
// 1
// last,扩展方法也被遍历出来了

所以遍历数组老老实实用 for...of 或经典 for。遍历对象时,如果只想要自己的属性,用 Object.keys(obj) 更稳:

const user = { name: "张三", age: 28 };
Object.keys(user).forEach((key) => {
  console.log(key, user[key]);
});
// name 张三
// age 28

Object.keys 只拿可枚举的自有字符串键,Symbol 键拿不到,要用 Reflect.ownKeys;原型上的属性也不会被带出来,这是它比 for...in 稳的地方。老项目里没有 Object.hasOwn 时,用 Object.prototype.hasOwnProperty.call(obj, key),别直接写 obj.hasOwnProperty,因为 Object.create(null) 出来的对象没有这个方法。

另外,for...in 的顺序在涉及数字键时不完全是「你写的顺序」,整数键会按升序排在前面。要严格顺序,用 Object.entries 加数组的处理方式,或者干脆用 Map。

forEach 的两个限制:不能 break、等不了异步

forEach 是数组方法,不是循环语句。它接受一个回调,对每个元素执行一次。用起来短,但有两个限制经常让人栽跟头。

第一,不能中途退出。回调里的 return 只是结束这一次回调,相当于 continue;break 在回调里是语法错误:

const list = [1, 2, 3, 4];
list.forEach((n) => {
  if (n === 2) return;        // 只是跳过 2,后面的 3、4 照跑
  console.log(n);
});
// 1 3 4

// 想「找到就停」,用 for...of
for (const n of list) {
  if (n === 2) break;
  console.log(n);
}
// 1

第二,回调里的 await 不会被外面等待:

async function saveAll(list) {
  list.forEach(async (item) => {
    await save(item);          // 这里确实在等,但 forEach 不等它
  });
  console.log("全部完成");      // 会先打印这句
}

forEach 执行时只是依次调用回调,拿到 Promise 就丢掉,不会收集起来等。要串行处理就写 for...of 加 await;要并发就 map 成 Promise 数组再 Promise.all。这两种写法的差别和取舍,在Promise 与 async/await里会细讲。

还有个隐蔽点:回调里抛错或 reject,forEach 本身不会接住,错误会变成未处理的 Promise rejection。控制台只报 Uncaught (in promise),不告诉你是哪一条数据,排查很费劲。forEach 适合纯同步的副作用,比如累加、打印、改 DOM;只要带 await,就换成 for...of 或显式的 Promise 数组。

要提前退出也不一定非用 for...of:some 找到就停,every 遇到 false 就停,find 找到返回元素,语义比手写 flag 清楚。比如检查有没有超过库存的项,用 some 一行就够。

break、continue 和那个很少人用的标签

break 结束整个循环,continue 跳过本次进入下一次。这在单层循环里没歧义,但嵌套两层时,break 只跳出最近的一层:

for (const row of rows) {
  for (const cell of row) {
    if (cell === target) {
      break;          // 只跳出内层,外层继续下一行
    }
  }
}

想一次跳出两层,可以加标签:

outer: for (const row of rows) {
  for (const cell of row) {
    if (cell === target) {
      break outer;
    }
  }
}

标签语法合法,但可读性一般。嵌套两层以上,更推荐把内层抽成函数,用 return 直接结束,意图更清楚。标签留到确实需要的地方再用。

continue 也能带标签,用来跳过外层循环的本次:

outer: for (const row of rows) {
  for (const cell of row) {
    if (cell === "skip") continue outer;
    console.log(cell);
  }
}

标签名尽量写 outer、rows 这种有含义的,别用 a、b。超过两层嵌套,抽函数用 return 更清楚;标签语法本身没错,错在让人多花时间理解控制流。

写 while 时确认循环体里一定会改变条件。经典的死循环是把 i++ 写在 continue 前面被跳过的那一支,页面直接卡死,控制台都没机会打印。

完整场景走查:批量审核 200 条

需求:审核后台勾选最多 200 条,点「批量通过」逐条调接口;页面显示「已处理 37 / 200」,失败的要列出来,支持只重试失败的;按钮不能重复点,服务端限流 50 QPS。

POST /api/audit/pass
{ "id": "A202611060017", "requestId": "batch-20261106-001-A202611060017" }

// 成功 200
// 重复提交返回 409
// 触发限流返回 429

第一版这样写:

let done = 0;

function batchPass(selected) {
  selected.forEach(async (item) => {
    await api.post("/api/audit/pass", { id: item.id });
    done += 1;
    renderProgress(done, selected.length);
  });
  toast("提交完成");
}

// 勾选数据是这么收集的
const selected = [];
for (const key in rows) {
  if (rows[key].checked) selected.push(rows[key]);
}

本地勾 5 条测,toast 马上弹出来,但 5 条也确实都成功了,看起来没问题。上线后勾 200 条:

  1. toast 立刻弹「提交完成」,进度条停在 3 / 200,过几秒才慢慢涨。
  2. 控制台一堆 Uncaught (in promise) Error: 429,进度不再动。
  3. 审核记录里多出一条 ID 是 "last" 的数据,因为老库给 Array.prototype 挂了 last 方法,for...in 把方法名也遍历进来了。
  4. 用户等不及点了两下,生成两批重复审核。

四个现象对应四个问题:forEach 不等 async 回调,所以 toast 提前;200 个请求同时发出去,直接撞限流,回调 reject 又没人接;for...in 遍历数组会带出原型上的可枚举属性;按钮没有运行锁,接口也没有幂等处理。

改法是去掉 for...in,用数组自己的方法收集 ID;把 forEach 换成固定并发的 worker 池;每个请求带幂等键,409 当成已成功;按钮加锁。并发数按「单请求平均 120 毫秒、服务端 50 QPS」估算,5 个并发大约 42 QPS,留一点余量:

const selectedIds = rows
  .filter(row => row.checked)
  .map(row => String(row.id));

let running = false;
let failedIds = [];

async function batchPass(ids, batchId, concurrency = 5) {
  const queue = ids.map(String);
  const failed = [];
  let done = 0;
  let cursor = 0;

  async function worker() {
    while (cursor < queue.length) {
      const id = queue[cursor];
      cursor += 1;
      try {
        await api.post("/api/audit/pass", {
          id,
          requestId: batchId + "-" + id
        });
      } catch (err) {
        if (err.status !== 409) failed.push(id);
      } finally {
        done += 1;
        renderProgress(done, queue.length);
      }
    }
  }

  await Promise.all(
    Array.from({ length: Math.min(concurrency, queue.length) }, worker)
  );
  return failed;
}

async function onSubmit() {
  if (running) return;
  running = true;
  const btn = document.querySelector("#batch-pass");
  btn.disabled = true;
  const batchId = "batch-" + Date.now();
  try {
    failedIds = await batchPass(selectedIds, batchId, 5);
    toast(failedIds.length ? `完成,${failedIds.length} 条失败` : "全部完成");
  } finally {
    running = false;
    btn.disabled = false;
  }
}

200 条、5 并发、单条 120 毫秒,总耗时约 200 ÷ 5 × 0.12 = 4.8 秒;同样数据一条条串行要 24 秒,用户早就关页面了。失败 7 条时只把这 7 条重新丢进 batchPass,并发降到 3,页面单独显示「重试 3 / 7」,不会把已成功的 193 条再提一遍。

错误现象对照

批量操作类页面的问题,现象通常比报错更早出现。先看表,再决定从哪一层查:

现象真实原因第一步查什么
点「批量通过」立刻弹「提交完成」,进度停在 3 / 200forEach 只调用回调,不等待 async 回调里的 await搜 forEach(async,改成 for...of 或 worker 池
控制台 Uncaught (in promise) Error: 429,进度不再动请求并发过高撞限流,回调 reject 没人接Network 看请求瀑布,确认是不是 200 个同时发出
提交记录里多出一条,ID 是 "last" 或 function last()for...in 遍历数组,带出了原型上的可枚举方法打印 Object.keys(rows),对比 rows.length
页面卡死,控制台没有新输出while 条件变量没更新,或 continue 跳过了自增看循环体里有没有一行一定会改变条件
勾了 10 条,只提交了 5 条循环里 splice 删除元素,后面的下标整体前移被跳过搜循环里的 splice,看有没有 i -= 1 或改用 filter
快速双击生成两批相同审核按钮没有运行锁,接口也没有幂等键看按钮是否 disabled,请求里有没有 requestId

边界与代价

并发不是越高越好。5 个并发在 120 毫秒的接口上约 42 QPS,刚好压在 50 QPS 限流下面;开到 20 个并发,瞬时 160 多 QPS,服务端一定开始返 429。判断标准是「并发数 ÷ 单请求耗时」要明显低于服务端限额,留 20% 余量,再准备失败重试。没有限流接口时也别一次放 200 个,浏览器对同域并发本身有限制,排队和超时更难排查。

串行也不是都不好。200 条每条 120 毫秒,串行 24 秒,用户等不了;但如果只有 5 条、每条要做 2 秒的复杂计算,串行 10 秒反而更稳,至少不会把服务打挂。数据量小的时候优先选简单写法,量大了再上并发池。

循环本身的代价也要看场景。几千条以内的数组,for...of 和经典 for 的差距可以忽略,选可读性好的;十万条以上的纯数值遍历,经典 for 加缓存长度会快一些,但更该考虑分页、虚拟列表或 Worker,别在主线程一次跑完。超过 50 毫秒的同步任务就可能掉帧,具体耗时先在本机测,不要凭感觉优化。

几个明确的边界:

  • for...in 永远不要用来遍历数组,字符串下标和原型属性两个问题都会遇到;对象遍历优先 Object.keys / Object.entries。
  • 循环里删数组元素,倒着遍历或者用 filter 生成新数组;正着 splice 必然漏元素。
  • do...while 至少执行一次,只适合「先做再判断」的场景;可能一次都不做就用 while。
  • while 的条件如果依赖外部状态,加最大次数或超时,否则接口一直不返回时页面会永远转圈。
  • 标签只能配合 break / continue 跳出被标记的语句块,不能跨函数;嵌套超过三层,抽函数用 return 比标签清楚。
控制流写错的共同点是「不报错,只是结果不对」。所以批量操作要有进度、要有失败清单、要有幂等键;这三样不是为了好看,是为了出问题时能定位到具体哪一条。

小结

分支先写守卫语句,主干逻辑别嵌套;状态翻译用映射表,但每个分支动作不同时别硬套。
数组用 for...of 或经典 for;for...in 是给对象键准备的,用在数组上会拿到字符串下标和原型属性。
forEach 不能真正 break,也不会等异步回调;要中途退出或串行 await,换成 for...of。

当天可以自己验证的几件事:

  1. 把一段 list.forEach(async item => await save(item)) 改成 for...of 加 await,在循环前后各打一条日志,确认顺序真的变了。
  2. 在控制台执行 Array.prototype.foo = 1,分别用 for...in 和 for...of 遍历同一个数组,比较输出;测完记得 delete Array.prototype.foo。
  3. 写一个三层嵌套的 if,再用守卫语句重写,数一下最大缩进从几层降到几层。
  4. 用 while 写一个最多重试 3 次的循环,故意让条件不满足,确认到达上限会退出而不是死循环。
  5. 搜你项目里所有 for...in 遍历数组的地方,换成 for...of 或 rows.filter,再检查一遍提交条数对不对。

下一篇讲函数与作用域。这一篇里「循环变量共享」「回调拿不到当时的值」「for...in 为什么能拿到原型上的东西」,根子都在函数和作用域上,那篇会把这条线接上。先读它,是因为你写的每个循环体、每个回调,最终都要回答「这个变量是从哪来的」。