JavaScript中forEach遍历数组方法详解

本篇文章向大家介绍《JavaScript中Array.prototype.forEach的作用是遍历数组中的每个元素，并对每个元素执行一次提供的函数。它不会改变原数组，而是依次对每个元素进行操作。语法：array.forEach(callback(currentValue, index, array), thisArg)callback：每次迭代时调用的函数。currentValue：当前处理的数组元素。index（可选）：当前元素的索引。array（可选）：正在处理的数组。thisArg（可选）：执行回调函数时使用的this值。示例：const fruits = ['apple', 'banana', 'orange']; fruits.forEach(function(fruit, index) { console.log(index + ': ' + fruit); });输出：0: apple 1: banana 2: orange注意事项：forEach 不会遍历对象的不可枚举属性。它不能使用 break 或 return 来提前终止循环。如果需要提前退出，可以使用 for 循环或 some()、every() 等方法。适用场景：当你需要对数组中的每个元素执行某些操作，如打印、修改、计算等。不需要返回新数组，只需对现有数组进行操作。》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

Array.prototype.forEach 是 JavaScript 中用于遍历数组并执行副作用操作的方法，它不返回新数组且无法中断循环。1. forEach 适用于遍历数组并执行如打印、修改 DOM 或累加等无返回值的操作；2. 它不支持异步等待，回调中的 async/await 不会阻止循环继续执行；3. 使用时需注意不能通过 return、break 或 continue 控制流程；4. 避免在遍历过程中修改原数组长度，可能导致跳过元素或无限循环；5. 回调中 this 的指向需通过 thisArg 指定或使用箭头函数保持上下文。

Array.prototype.forEach 是 JavaScript 中一个非常常用的数组迭代方法，它允许你遍历数组的每个元素，并对每个元素执行一个回调函数。它不会改变原数组，也不会返回新数组，主要用于执行副作用操作，比如打印、修改 DOM 元素等。

使用 forEach 很直接。你只需要在一个数组实例上调用它，并传入一个回调函数作为参数。这个回调函数会在数组的每个元素上被执行一次。

const numbers = [1, 2, 3, 4, 5];

// 回调函数可以接收三个参数：
// item: 当前遍历到的元素
// index: 当前元素的索引
// array: 正在遍历的原始数组
numbers.forEach(function(item, index, array) {
  console.log(`元素在索引 ${index} 处的值是: ${item}`);
  // 实际上，array 参数不常用，但了解它存在是有益的
});

// 实际开发中，更常见的是使用箭头函数，它更简洁：
const fruits = ['apple', 'banana', 'cherry'];
fruits.forEach((fruit, i) => {
  console.log(`我喜欢 ${fruit} (索引 ${i})`);
});

// forEach 的常见用途：
// 1. 简单地遍历并打印数组内容，或者进行一些不产生新数组的操作。
// 2. 对每个元素执行一些 DOM 操作，比如为所有列表项添加样式。
const listItems = document.querySelectorAll('.my-list li'); // 假设页面中有这样的元素
if (listItems.length > 0) { // 确保元素存在，避免运行时错误
  listItems.forEach(item => {
    item.classList.add('highlight'); // 给每个列表项添加一个高亮类
  });
}


// 3. 累加或计算总和，但需要注意的是，forEach 不返回结果，所以你得在外部维护一个变量。
let sum = 0;
numbers.forEach(num => {
  sum += num;
});
console.log(`所有数字的总和是: ${sum}`); // sum 现在是 15

// 重要的是要理解：forEach 不会等待异步操作完成。
const urls = ['/api/data1', '/api/data2'];
urls.forEach(async url => {
  // 这里的 async/await 不会暂停 forEach 循环的执行。
  // forEach 会立即迭代到下一个元素，不会等待当前的 fetch 完成。
  try {
    const response = await fetch(url);
    const data = await response.json();
    console.log(`成功获取 ${url} 的数据:`, data);
  } catch (error) {
    console.error(`获取 ${url} 失败:`, error);
  }
});
console.log('forEach 循环已经执行完毕，但网络请求可能还在后台进行中。');
// 如果你需要等待所有异步操作完成，通常会考虑使用 Promise.all 配合 map，或者 for...of 循环。

### forEach与for循环、map、filter等其他迭代方法的区别是什么？

这确实是 JavaScript 数组方法里一个经常让人感到困惑的地方，毕竟它们都能遍历数组。`forEach` 最核心的特点就是它**只管迭代，不返回任何东西**（它的返回值永远是 `undefined`）。这意味着你不能像 `map` 或 `filter` 那样，在 `forEach` 后面直接链式调用其他数组方法。它存在的意义，就是让你能够对数组的每个元素执行一些“副作用”操作，比如打印到控制台，或者修改页面上的 DOM 元素。

举个例子，如果你想把一个数组里的所有数字都翻倍，然后得到一个新数组，那么 `map` 才是你的最佳选择：

```javascript
const originalNumbers = [1, 2, 3];
const doubledNumbers = originalNumbers.map(num => num * 2);
console.log(doubledNumbers); // 输出: [2, 4, 6]
console.log(originalNumbers); // 输出: [1, 2, 3] - 原数组保持不变，这是 map 的一个优点

而如果你用 forEach 来做这个，你就得在外部声明一个新数组，然后在 forEach 里面手动 push：

const originalNumbersForForEach = [1, 2, 3];
const newArrayWithForEach = [];
originalNumbersForForEach.forEach(num => {
  newArrayWithForEach.push(num * 2);
});
console.log(newArrayWithForEach); // 输出: [2, 4, 6]
// 看起来也能实现，但不如 map 声明式和简洁。

filter 呢，顾名思义就是“过滤”。它也返回一个新数组，但这个新数组只包含那些回调函数返回 true 的元素。它非常适合从数组中筛选出符合特定条件的子集：

const allNumbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = allNumbers.filter(num => num % 2 === 0);
console.log(evenNumbers); // 输出: [2, 4, 6]

至于传统的 for 循环（包括 for (let i = 0; i < arr.length; i++)、for...of 和 for...in），它们提供了最底层的控制能力。for 循环最大的优势在于你可以随时 break（中断循环）或 continue（跳过当前迭代），也可以在循环内部灵活地修改索引。这些是 forEach 无法做到的，forEach 的设计理念就是简单地遍历所有元素，不提供中断机制。当你需要更精细的控制，或者处理需要等待前一个操作完成的异步任务时，for...of 循环配合 await 往往是更好的选择：

const items = [10, 20, 30, 40];
for (let i = 0; i < items.length; i++) {
  if (items[i] === 30) {
    console.log('找到 30 了，中断循环！');
    break; // forEach 不支持 break
  }
  console.log(items[i]);
}
// 输出: 10, 20, 找到 30 了，中断循环！

async function processDataSequentially() {
  const dataIds = ['id_A', 'id_B', 'id_C'];
  for (const id of dataIds) {
    console.log(`开始处理 ID: ${id}`);
    // 假设这里是耗时的异步操作，for...of 循环会等待它完成
    await new Promise(resolve => setTimeout(resolve, 500));
    console.log(`ID: ${id} 处理完毕。`);
  }
  console.log('所有数据都按顺序处理完了。');
}
processDataSequentially();

所以，选择哪个方法，真的取决于你的具体需求：是想遍历并执行操作（forEach），还是想转换生成一个新数组（map），还是想从数组中筛选出子集（filter），或者你需要更底层的控制和异步操作的顺序执行（for 循环或 for...of）。

在使用forEach时，有哪些常见的陷阱或需要注意的地方？

forEach 确实非常方便，但它也有自己的“脾气”和一些需要留心的地方，不然可能会踩到坑。

首先，也是最重要的一点：forEach 不能中断循环。如果你在回调函数里 return 了，或者尝试使用 break 甚至 continue，它都不会像传统的 for 循环那样停止或跳过当前迭代。forEach 会坚定不移地把数组里的每个元素都走一遍。这就意味着，如果你想在找到某个特定元素后就停止遍历，或者在满足某个条件时提前退出，forEach 就不是合适的工具了。这时候，你可能需要回过头用 for...of 循环，或者考虑 Array.prototype.some()（只要有一个元素满足条件就返回 true 并停止）或 Array.prototype.every()（所有元素都满足条件才返回 true）。

const numbersToFind = [10, 20, 30, 40];
let found = false;
numbersToFind.forEach(num => {
  if (num === 30) {
    console.log('在 forEach 里找到 30 了，但循环不会停止。');
    // return; // 这里 return 只是退出当前回调，不退出 forEach 循环
    // break; // SyntaxError: Illegal break statement
  }
  console.log(num);
});
console.log('forEach 已经遍历完所有元素，即使找到了目标。');

// 如果想提前退出，可以这样做：
const hasThirty = numbersToFind.some(num => {
  if (num === 30) {
    console.log('some 方法找到 30 了，并停止了遍历。');
    return true; // 返回 true 会让 some 停止并返回 true
  }
  console.log(num);
  return false;
});
console.log(`数组中是否包含 30？ ${hasThirty}`);
// 输出：
// 10
// 20
// some 方法找到 30 了，并停止了遍历。
// 数组中是否包含 30？ true

另一个需要特别留意的点是，forEach 的回调函数是同步执行的。即使你在回调函数内部使用了 async/await，forEach 本身也不会等待这些异步操作完成。它会立即继续处理下一个元素。这可能导致一些出乎意料的行为，尤其是在处理大量异步请求时。你可能会看到 forEach 循环“瞬间”完成，但实际的网络请求或文件操作还在后台默默进行。

const userIds = [101, 102, 103];
userIds.forEach(async id => {
  console.log(`开始为用户 ID: ${id} 获取数据...`);
  // 模拟一个异步操作，比如从服务器获取用户详情
  await new Promise(resolve => setTimeout(resolve, 200 * id)); // 模拟不同耗时
  console.log(`用户 ID: ${id} 的数据获取完毕。`);
});
console.log('forEach 循环本身已经执行完毕，但异步数据获取还在进行中。');
// 你会发现控制台先打印出所有“开始获取”和“forEach 循环完毕”，然后才陆续打印“数据获取完毕”。

还有，forEach 在遍历过程中不应该修改原数组的长度。如果在 forEach 内部添加或删除了元素，行为可能会变得非常奇怪且难以预测。例如，如果你删除了当前正在遍历的元素，后面的元素可能会被跳过；如果你添加了元素，新添加的元素可能不会被遍历到，或者在某些边缘情况下导致无限循环（虽然在 forEach 中修改长度导致无限循环的情况比较少见，但在传统的 for 循环里更容易出现）。最佳实践是保持原数组的稳定，如果需要修改，考虑 map 或 filter 返回新数组，或者在遍历前就确定好所有操作。

最后，是关于 this 上下文的问题。在非箭头函数的 forEach 回调中，this 的指向默认是 undefined（在严格模式下）或全局对象（非严格模式下），而不是你期望的调用 forEach 的那个对象。虽然 forEach 提供了第二个参数 thisArg 来绑定 this，但使用箭头函数通常是更简洁、更现代的解决方案，因为箭头函数会捕获其定义时的 this。

const userProcessor = {
  prefix: 'User:',
  users: ['Alice', 'Bob'],
  processUsers: function

终于介绍完啦！小伙伴们，这篇关于《JavaScript中forEach遍历数组方法详解》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！