后台有个批量审核页面,勾选多条记录后循环处理,代码用了 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 条:
- toast 立刻弹「提交完成」,进度条停在 3 / 200,过几秒才慢慢涨。
- 控制台一堆
Uncaught (in promise) Error: 429,进度不再动。 - 审核记录里多出一条 ID 是
"last"的数据,因为老库给Array.prototype挂了last方法,for...in把方法名也遍历进来了。 - 用户等不及点了两下,生成两批重复审核。
四个现象对应四个问题: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 / 200 | forEach 只调用回调,不等待 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。当天可以自己验证的几件事:
- 把一段
list.forEach(async item => await save(item))改成for...of加await,在循环前后各打一条日志,确认顺序真的变了。 - 在控制台执行
Array.prototype.foo = 1,分别用for...in和for...of遍历同一个数组,比较输出;测完记得delete Array.prototype.foo。 - 写一个三层嵌套的
if,再用守卫语句重写,数一下最大缩进从几层降到几层。 - 用
while写一个最多重试 3 次的循环,故意让条件不满足,确认到达上限会退出而不是死循环。 - 搜你项目里所有
for...in遍历数组的地方,换成for...of或rows.filter,再检查一遍提交条数对不对。
下一篇讲函数与作用域。这一篇里「循环变量共享」「回调拿不到当时的值」「for...in 为什么能拿到原型上的东西」,根子都在函数和作用域上,那篇会把这条线接上。先读它,是因为你写的每个循环体、每个回调,最终都要回答「这个变量是从哪来的」。