一、forEach()到底是什么

JavaScript数组自带一批迭代方法，forEach()是其中使用频率较高的一個。它挂在Array.prototype上，Node.js作为JavaScript运行时自然完整支持，并不存在"Node.js专属的forEach"这种说法——这一点在不少资料里容易被表述得含糊。准确理解是：它是ECMAScript标准里的数组实例方法，Node.js环境直接可用。

从函数式编程的角度看，forEach()属于高阶函数：它接收一个回调函数作为参数，并在内部为数组的每个元素调用一次这个回调。调用方不需要自己维护循环变量、不需要写i++、不需要判断边界，迭代的控制权交给了方法本身。

需要先明确一个关键定位：forEach()的职责是"对每个元素执行某个操作"，它不负责"产出一个新数组"。这个定位决定了它和map()、filter()的分工，也是后面很多误用的根源。

const scores = [88, 92, 75, 60];

scores.forEach(function (score, index) {
  console.log(`代码号学习编程 第 ${index + 1} 位学员成绩：${score}`);
});

二、语法与参数逐项拆解

标准语法如下：

array.forEach(callback(currentValue[, index[, array]])[, thisArg])

拆开来看，涉及两层参数。

第一层：forEach自身接收的参数

参数	是否必填	说明
callback	必填	每个元素执行的回调函数
thisArg	可选	执行callback时用作this的值

第二层：callback被调用时收到的参数

参数	是否必填	说明
currentValue	必填	当前正在处理的元素
index	可选	当前元素的索引
array	可选	正在被遍历的数组本身

回调的三个参数按顺序传入，实际使用时按需声明即可，不需要的参数直接省略。比如只关心元素值时写(item)=>{}，同时需要索引时写(item,index)=>{}。

关于thisArg，有一个实践中的提醒：箭头函数没有自己的this，传入thisArg对箭头函数回调不起作用。如果确实需要绑定this，应使用普通函数表达式。不过在Node.js现在代码中，箭头函数配合外部变量闭包已能满足绝大多数需求，thisArg的使用场景并不多见。

const collector = {
  items: [],
  collect(value) {
    this.items.push(value);
  }
};

const nums = [1, 2, 3];

// 普通函数 + thisArg，this 指向 collector
nums.forEach(function (n) {
  this.collect(n);
}, collector);

console.log(collector.items); // [1, 2, 3]

// 箭头函数无法被 thisArg 改变 this，下面这种写法达不到预期
// nums.forEach((n) => { this.collect(n); }, collector);

三、执行行为：几个必须记牢的细节

按索引升序执行。遍历顺序由数组索引从0开始递增决定，与元素值大小无关。

不改变原数组。forEach()本身不会修改调用它的数组。但要注意，回调内部如果对元素对象做了属性修改，那是回调的行为，不是forEach的行为。元素是对象时，修改对象属性会反映到原数组上，因为数组里存的是引用。

返回值固定为undefined。这一点直接影响链式调用。arr.forEach(...).map(...)这样的写直接报错，因为undefined上没有map方法。

遍历范围在调用时确定。forEach开始执行时，数组的长度和已存在的索引范围就固定了。回调执行期间往数组尾部追加的元素不会被访问；而已经访问过的位置若被删除，也不会回头再访问。

稀疏数组的空位会被跳过。这是容易踩坑的地方，下一节单独展开。

异常会中断遍历。回调里抛出错误，forEach不会捕获，会直接向上抛出并终止后续元素的处理。需要逐元素容错时，应在回调内部自行try/catch。

四、稀疏数组与空位：一个高频误区

原始资料里有一个例子值得纠正。类似[11,24,32,,37]这种写法，中间那个逗号制造的是一个"空位"（hole），数组长度为5，但索引3位置上并没有元素。

forEach()对空位的处理规则是：跳过，不调用回调。因此输出只有11、24、32、37四个值，索引3根本不会被访问，回调里的index也不会出现3这个值。如果回调里写了console.log(index)，会看到索引是0、1、2、4，中间断开。

这一点和"元素值为undefined"不同。显式写了[11,24,32,undefined,37]时，索引3是真实存在的元素，forEach会正常访问它，回调收到currentValue为undefined。

const sparse = [11, 24, 32, , 37];
let visited = [];
sparse.forEach((v, i) => visited.push(i));
console.log(visited); // [0, 1, 2, 4]  索引 3 被跳过

const explicit = [11, 24, 32, undefined, 37];
let visited2 = [];
explicit.forEach((v, i) => visited2.push(i));
console.log(visited2); // [0, 1, 2, 3, 4]  索引 3 被访问

项目中的实际意义：从接口拿到的JSON数组通常不会出现空位，但手工构造的数组、deletearr[2]之后留下的数组、newArray(5)创建的空数组，都可能带空位。做数据统计时如果依赖forEach计数，结果可能少于预期长度，排查时先确认数组是否稀疏。要统一处理空位，可以先用Array.from(arr)或展开运算符转换，它们会把空位转成undefined。

五、代码号学习编程示例

示例一：基础遍历与索引拼接

const courses = ['Node.js 基础', '数组方法精讲', '异步编程', 'Express '];

courses.forEach((course, index) => {
  console.log(`代码号学习编程 · 第 ${index + 1} 课：${course}`);
});

输出按顺序打印四门课程及编号。这类"逐条输出、逐条记录"的场景，是forEach最本职的用法。

示例二：累加统计（说明为何此处更适合reduce）

const orders = [128, 56, 340, 99];

let total = 0;
orders.forEach((amount) => {
  total += amount;
});

console.log(total); // 623

这段代码能跑，但用forEach做累加属于"能用但不推荐"。累加本质是归约操作，reduce能更清晰地表达意图，且变量作用域更收敛：

const total2 = orders.reduce((sum, amount) => sum + amount, 0);
console.log(total2); // 623

个人建议：需要"聚合出一个结果"时优先reduce，forEach留给"只做副作用、不需要返回值"的场景。这个区分能显著降低代码的阅读成本。

示例三：对象数组处理与引用修改

const students = [
  { name: '小林', score: 78 },
  { name: '小周', score: 91 },
  { name: '小陈', score: 65 }
];

students.forEach((student) => {
  student.passed = student.score >= 70;
});

console.log(students);
// 每个对象都新增了 passed 字段，原数组元素被修改

这里要强调：forEach没有"返回新数组"的能力，回调里改的是原对象。如果业务上希望保留原始数据，应该用map生成新对象数组，而不是在forEach里原地改。数据不可变原则在多人协作和状态管理场景中价值很高，改之前先问一句"原始数据还要不要"。

示例四：配合Set去重收集

const tags = ['node', 'js', 'node', 'array', 'js'];
const unique = new Set();

tags.forEach((tag) => unique.add(tag));

console.log([...unique]); // ['node', 'js', 'array']

Set的add本身幂等，用forEach逐个塞入是直观写法。不过同一目标也可写成[...newSet(tags)]，更短。选择forEach的理由通常是回调里还有额外逻辑（比如过滤、日志、格式转换），单纯去重时不必绕这一圈。

六、forEach与异步：最容易出错的组合

这是中必须点明的问题。forEach不理解async/await，它同步地把回调依次调用一遍，回调返回的Promise被直接丢弃，forEach不会等待任何一个完成。

const ids = [1, 2, 3];

async function fetchUser(id) {
  return { id, name: `用户${id}` };
}

// 错误示范：forEach 不会等待，外层拿不到结果
async function bad() {
  const results = [];
  ids.forEach(async (id) => {
    const user = await fetchUser(id);
    results.push(user);
  });
  console.log(results); // 很可能是 []，因为 await 还没回来
}

// 正确做法一：for...of 串行
async function serial() {
  const results = [];
  for (const id of ids) {
    results.push(await fetchUser(id));
  }
  return results;
}

// 正确做法二：Promise.all + map 并行
async function parallel() {
  return Promise.all(ids.map((id) => fetchUser(id)));
}

经验上，涉及异步的批量处理，先判断能否并行：彼此独立、无顺序依赖，用Promise.all配map，吞吐更好；有先后依赖或需要限流，用for...of串行。两条路都比forEach加async可靠。曾经在数据同步任务里见过forEach套async导致部分记录静默丢失，问题隐蔽在于不报错、只是少数据，排查成本很高。

七、中途退出：forEach做不到的事

forEach没有内置的break或continue。回调里写break是语法错误；写return只是结束当前这一次回调，相当于continue，不会终止整个遍历。

const nums = [3, 8, 15, 22];

// return 等价于 continue
nums.forEach((n) => {
  if (n < 10) return;
  console.log(n); // 15、22
});

确实需要"找到即停"时，有几种替代：

• 用for...of配break，最直接；

• 用some()或every()，通过返回值控制是否提前结束；

• 用find()/findIndex()，本身就是"找到第一个就返回"的语义。

// some 实现"找到第一个大于 10 的就停"
nums.some((n) => {
  if (n > 10) {
    console.log('首个大于 10 的值：', n); // 15
    return true; // 返回 true 终止遍历
  }
  return false;
});

选型思路很简单：遍历目的如果是"搜索/判断存在性"，语义上就不该用forEach，用find或some让代码自己说明意图，后来人读起来也省事。

八、与其他迭代方式的选择

方式	返回值	能否中断	是否适合异步	典型用途
forEach	undefined	不能	不适合	纯副作用遍历
map	新数组	不能	配Promise.all可用	元素转换
filter	新数组	不能	不常用	条件筛选
reduce	任意累积值	不能	不常用	聚合计算
for...of	无	能break/continue	配await串行	需要流程控制
for循环	无	能	可配await	需要索引精细控制

一个常见反思：看到数组就条件反射写forEach，是不少代码库里的惯性。实际上先问"我要不要产出、要不要中断、要不要等待"，答案往往指向别的方法。forEach的适用面比想象中窄，但用对了确实清爽。

九、本节课程知识要点

1. forEach是数组原型方法，属于ECMAScript标准，Node.js原生支持，回调按索引升序对每个存在的元素执行一次。

2. 回调可接收currentValue、index、array三个参数，thisArg对箭头函数无效。

3. 返回值为undefined，不能参与链式调用；不改变原数组本身，但回调可修改元素对象属性。

4. 稀疏数组的空位被跳过，与显式undefined元素行为不同，统计类逻辑要留意。

5. 不支持break，return仅相当于continue；需要提前终止时改用for...of、some、every、find。

6. 与async/await组合不会等待，异步批处理应使用for...of串行或Promise.all并行。

7. 回调抛错会中断遍历，逐元素容错需在回调内try/catch。

8. 聚合用reduce、转换用map、筛选用filter、搜索用find，副作用遍历才轮到forEach。

十、练习与思考

1. 给定一个可能含空位的数组[1,,3,,5]，分别用forEach和Array.from转换后再forEach，对比回调被调用的次数，解释差异原因。

2. 写一段代码，用forEach给对象数组每个元素添加序号字段，再改写为不修改原数组的map版本，比较两者在"原始数据是否保留"上的区别。

3. 有一个异步函数save(item)返回Promise，数组有20个元素。分别用forEach、for...of、Promise.all实现批量保存，说明三者在执行顺序、错误传播、完成时机上的不同。

4. 用some实现"在数组中查找第一个满足条件的元素并输出其索引"，对比forEach加标志位变量的写法，评估可读性。

十一、注意事项汇总

• 不要用forEach做需要返回值或链式处理的事情，undefined会让后续调用失败。

• 不要在forEach回调里写async并期待顺序执行，Promise会被丢弃。

• 不要依赖forEach遍历稀疏数组的"完整长度"，空位不触发回调。

• 不要在回调里对原数组做增删改长度类操作，遍历范围已固定，行为容易偏离预期。

• 需要中断、需要索引精细控制、需要异步等待时，优先考虑for...of或for循环。

• 回调内的异常若不处理会中断整个遍历，批量任务中建议逐项包裹错误处理并记录失败项，避免一条脏数据拖垮整批处理。

forEach的语法门槛不高，真正拉开差距的是对它边界条件的认识：它不返回值、不能中断、不等待异步、跳过空位。把这些行为记清楚，再结合map、reduce、for...of各自的语义做选择，数组迭代代码会明显更稳、更好读。工具本身没有优劣，用在对的位置才有价值。