js forEach参数详解

壹 ❀ 引

在 JS 开发工作中，遍历数组的操作可谓十分常见了，那么像 for 循环，forEach 此类方法自然也不会陌生，直到遇到了一个有趣的问题，来看一段代码：

let arr = [1, 2];
arr.forEach((item, index) => {
  arr.splice(index, 1);
  console.log(1); //输出几次？
});
console.log(arr); //?

1
[2]

这段代码执行完毕后 arr 输出为多少？循环体内的 console 操作会执行几次？

贰 ❀ forEach 参数

与 for 循环一样，forEach 也属于完整遍历数组的方法，并会对数组每项元素执行提供的回调函数，一个完整的 forEach 应该是这样，一一解释回调函数的参数，与后方的 this 有何作用。

arr.forEach(function (self, index, arr) {}, this);

self：数组当前遍历的元素，默认从左往右依次获取数组元素。
index：数组当前元素的索引，第一个元素索引为 0，依次类推。
arr：当前遍历的数组。
this：回调函数中 this 指向。

来看个简单的 forEach 例子，加强对于这四个参数的印象：

let arr1 = [1, 2, 3, 4];
let obj = {
  a: 1,
};
arr1.forEach(function (self, index, arr) {
  console.log(`当前元素为${self}索引为${index},属于数组${arr}`);
  //做个简单计算
  console.log(self + this.a);
}, obj);

可以看到，arr 参数其实就是正在遍历的数组，而回调函数中的 this 指向提供的 obj。是不是非常简单？
第三个参数 arr 有啥意义，遍历自己还提供自己作为参数，其实这个参数还挺好用，比如可以利用它做数组去重，像这样：

let arr1 = [1, 2, 1, 3, 1];
let arr2 = [];
arr1.forEach(function (self, index, arr) {
  arr.indexOf(self) === index ? arr2.push(self) : null;
});
console.log(arr2); //[1,2,3]

叁 ❀ forEach 使用的坑

1.forEach 不支持 break

在使用 for 循环时可以使用 break 跳出循环，比如希望找到数组中符合条件的第一个元素就跳出循环，这对于优化数组遍历是非常棒的。很遗憾，forEach 并不支持 break 操作，使用 break 会导致报错。

let arr = [1, 2, 3, 4],
  i = 0,
  length = arr.length;
for (; i < length; i++) {
  console.log(arr[i]); //1,2
  if (arr[i] === 2) {
    break;
  };
};

arr.forEach((self,index) => {
  console.log(self);
  if (self === 2) {
    break; //报错
  };
});

那 forEach 能不能跳出循环呢？可以，不过不是使用 break，而是结合 try catch 操作

try {
  var arr = [1, 2, 3, 4];
  arr.forEach(function (item, index) {
    //跳出条件
    if (item === 3) {
      throw new Error("LoopTerminates");
    }
    //do something
    console.log(item);
  });
} catch (e) {
  if (e.message !== "LoopTerminates") throw e;
}

2.forEach 中使用 return 无效

首先需要确定的，直接再 for 循环中使用 return 会报错（函数中使用 for 可以 return），forEach 中使用 return 不会报错，但 rerutn 并不会生效，来看个例子：

let arr = [1, 2, 3, 4];

function find(array, num) {
  array.forEach((self, index) => {
    if (self === num) {
      return index;
    }
  });
}
let index = find(arr, 2); // undefined

上述代码想要找到数字 2 在数组中的索引，但 return 并不会起到终止代码运行并返回值的作用。
当然如果真的要用 return 返回某个值，那就只能将 return 操作放在函数中，而不是 forEach 循环中，像这样：

function find(array, num) {
  let _index;
  array.forEach((self, index) => {
    if (self === num) {
      _index = index;
    }
  });
  return _index;
}

3.forEach 删除自身元素 index 不会被重置

还记得文章开头的问题吗，那段代码其实只会执行一次，数组也不会被删除干净，这是因为 forEach 在遍历跑完回调函数后，会隐性让 index 自增，像这样：

arr.forEach((item, index) => {
  arr.splice(index, 1);
  console.log(1);
  //这里隐性让index自增加1
  index++;
});

当第一次遍历结束，此时数组为[2]而 index 变成了 1，此时数组最大索引只是 0，不满足条件，所以跳出了循环。
灵机一动，有没有什么办法让此时的 forEach 不跳出循环呢，当然有，使用 ES6 的拓展运算符。

[...arr].forEach((item, index) => {
  arr.splice(index, 1);
  console.log(1);
});

通过拓展运算符重置数组 arr，达到不跳出循环的目的，会发现内部确实执行了两次，很遗憾的是 index 依旧没被重置，所以数组 arr 还是无法在遍历的同时删空自己。

因为在实际开发中，遍历数组同时删除某项的操作十分常见，所以对于习惯了 forEach 的人，这一点一定要注意。

肆 ❀ for 与 forEach 的区别

那么说到这里，for 循环与 forEach 有什么区别呢？应该都能说上几点了吧，比如：

1. for 循环可以使用 break 跳出循环，但 forEach 不能。
2. for 循环可以控制循环起点（i 初始化的数字决定循环的起点），forEach 只能默认从索引 0 开始。
3. for 循环过程中支持修改索引（修改 i），但 forEach 做不到（底层控制 index 自增，无法左右它）。

伍 ❀ 数组遍历并删除自身

怎么在遍历一个数组的同时，并删除符合条件的所有项呢？

其实很简单，可以使用 for 循环，像这样：

let arr = [1, 2, 1],
  i = 0,
  length = arr.length;

for (; i < length; i++) {
  // 删除数组中所有的1
  if (arr[i] === 1) {
    arr.splice(i, 1);
    //重置i，否则i会跳一位
    i--;
  }
}
console.log(arr); //[2]

删除符合条件的所有项，不就是过滤吗？过滤，本能想到 filter 方法，也很简单：

var arr1 = arr.filter((index) => {
  return index !== 1;
});
console.log(arr1); //[2]

更少的代码量，只是得新建一个变量来接受 filter 方法的返回值。

非要用 forEach 去做这个功能行不行，当然行，只是得让数组反过来遍历：

arr
  .slice()
  .reverse()
  .forEach(function (item, index, arr1) {
    if (item === 1) {
      arr.splice(arr1.length - 1 - index, 1);
    }
  });
console.log(arr); //[2]

for 循环和 forEach 的性能区别

在性能对比方面加入一个 map 迭代器，它与 filter 一样都是生成新数组。对比 for forEach map 的性能在浏览器环境中都是什么样的：

性能比较：for > forEach > map 在 chrome 62 和 Node.js v9.1.0 环境下：for 循环比 forEach 快 1 倍，forEach 比 map 快 20%左右。

原因分析 for：for 循环没有额外的函数调用栈和上下文，所以它的实现最为简单。forEach：对于 forEach 来说，它的函数签名中包含了参数和上下文，所以性能会低于 for 循环。map：map 最慢的原因是因为 map 会返回一个新的数组，数组的创建和赋值会导致分配内存空间，因此会带来较大的性能开销。

如果将 map 嵌套在一个循环中，便会带来更多不必要的内存消耗。当使用迭代器遍历一个数组时，如果不需要返回一个新数组却使用 map 是违背设计初衷的。在前端合作开发时见过很多人只是为了遍历数组而用 map 的，这点应该注意一下