几种遍历方法中for执行最快，它没有任何额外的函数调用栈和上下文。但在实际开发中我们要结合语义话、可读性和程序性能，去选择究竟使用哪种方案。下面来看for , foreach , map , for...in , for...of五种方法现场battle。
9 L/ t9 M/ }2 n5 \  @自我介绍

for
我是最早出现的一方遍历语句，在座的各位需称我一声爷爷。我能满足开发人员的绝大多数的需求。

9 V# ?& q% a6 O/ Q' i8 Q# o// 遍历数组
let arr = [1,2,3];
" }+ i" W2 `9 l& x+ E1 K$ `for(let i = 0;i < arr.length;i++){
( ?. x# V, i9 n/ E    console.log(i) // 索引，数组下标
1 s2 i% e+ e2 b    console.log(arr) // 数组下标所对应的元素
, L; P) h; T. x0 s. P}

% o2 e* i2 x' M, H* I// 遍历对象
let profile = {name:"April",nickname:"二十七刻",country:"China"};
1 ]* m. h: S$ Z* [6 p& Q$ j* efor(let i = 0, keys=Object.keys(profile); i < keys.length;i++){
    console.log(keys) // 对象的键值
    console.log(profile[keys]) // 对象的键对应的值
* f6 v! V1 o( D/ u6 }+ {}
' T. I1 X+ T8 v; q
// 遍历字符串
let str = "abcdef";
for(let i = 0;i < str.length ;i++){
    console.log(i) // 索引 字符串的下标
% ?# i% P6 ^# ?$ h, z    console.log(str) // 字符串下标所对应的元素
}

9 s) l8 q" `7 F2 m5 J4 m( E5 B9 w// 遍历DOM 节点
1 E9 c8 @# b, r' Dlet articleParagraphs = document.querySelectorAll('.article > p');
+ i$ ?# W* N/ Xfor(let i = 0;i<articleParagraphs.length;i++){
    articleParagraphs.classList.add("paragraph");
! k! m0 E, x4 `# o8 n5 c! m    // 给class名为“article”节点下的 p 标签添加一个名为“paragraph” class属性。
}

6 T. B4 E0 w7 M
4 g+ R; Y4 X6 _* |8 DforEach
6 D" _. c3 c" Q, Y0 [

  r! c7 B6 A0 n$ C我是ES5版本发布的。按升序为数组中含有效值的每一项执行一次 callback 函数，那些已删除或者未初始化的项将被跳过（例如在稀疏数组上）。我是 for 循环的加强版。
( |* c7 S# k& N0 @6 x7 Y
3 W* L; o4 b1 x
// 遍历数组

7 E; O$ r( M3 y3 F; @1 d7 mlet arr = [1,2,3];
8 [$ V% ^; X: }4 C# {arr.forEach(i => console.log(i))

// logs 1
5 S7 i% z* Y/ R6 E; ^// logs 2
% Q% o5 P* Y. [( q3 e// logs 3
// 直接输出了数组的元素

//遍历对象
let profile = {name:"April",nickname:"二十七刻",country:"China"};
& U# p1 V+ P7 R3 m; Rlet keys = Object.keys(profile);
keys.forEach(i => {
- B+ T5 {$ l. a    console.log(i) // 对象的键值
    console.log(profile) // 对象的键对应的值
: Q1 c5 A, _$ e( G) b+ M})


map
* R: H5 H9 B( u# m, d2 H, I' [1 t
% e" |9 ?. D& b( Y& U2 I" {
我也是ES5版本发布的，我可以创建一个新数组，新数组的结果是原数组中的每个元素都调用一次提供的函数后的返回值。let arr = [1,2,3,4,5];
; ?5 k: c7 f& \  }+ ?
let res = arr.map(i => i * i);

4 R- R& y+ w: C* }. z+ rconsole.log(res) // logs [1, 4, 9, 16, 25]
% V& Q7 F( t, Z% Z! w: b& ]

+ [1 z- {+ j# a! P; K, W- ?7 z( Qfor...in枚举
- Q4 F% {- _3 X' T5 b: _5 I7 I* k
" i& `/ }4 \! b' Q/ p; o
我是ES5版本发布的。以任意顺序遍历一个对象的除Symbol以外的可枚举属性。
1 Q% E' ^: Q2 S( I5 R

5 f8 x7 `3 R& Y7 A6 L- W# Q// 遍历对象

4 u' G' J% k& Glet profile = {name:"April",nickname:"二十七刻",country:"China"};
9 n* [8 r% e" q9 Wfor(let i in profile){
    let item = profile;
    console.log(item) // 对象的键值
    console.log(i) // 对象的键对应的值

" z. C& t4 D$ x# y# n! w3 q9 J// 遍历数组
let arr = ['a','b','c'];
for(let i in arr){
' ^% ^2 U+ P' d5 M    let item = arr;
( V3 e4 \7 ~7 ^    console.log(item) // 数组下标所对应的元素
; \2 }: y  E1 u- j5 {  s- t# Q    console.log(i) // 索引，数组下标
$ ]; d% M# s$ D# D, {6 m: v
// 遍历字符串
let str = "abcd"
% G% P# k; A. ifor(let i in str){
    let item = str;
5 Z# \% ]* E: L    console.log(item) // 字符串下标所对应的元素
    console.log(i) // 索引 字符串的下标
; j  p7 \( {+ d# W) z}
: ~2 |% k# a0 G, C8 s: |
/ R& q& m& n* L
+ N+ a0 D+ w0 [$ S8 z+ _for...of迭代


! I* Z9 }: n7 f, G3 B我是ES6版本发布的。在可迭代对象（包括 Array，Map，Set，String，TypedArray，arguments 对象等等）上创建一个迭代循环，调用自定义迭代钩子，并为每个不同属性的值执行语句。

// 迭代数组数组
7 G3 O' W- K( ^/ ~$ ?# clet arr = ['a','b','c'];
for(let item of arr){
    console.log(item)
}
// logs 'a'
// logs 'b'
// logs 'c'

// 迭代字符串
let str = "abc";
; H' ?5 ~- ]9 b3 m7 b( r" ^( yfor (let value of str) {
: n5 c. O8 @* C5 z3 i- _7 C8 ?    console.log(value);
}
// logs 'a'
// logs 'b'
. g& P3 C, g6 ?7 z' f' C// logs 'c'
' F. K/ Y& ?! Z
// 迭代map
let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]
" ~3 K  a$ m  g% \( @% ^for (let entry of iterable) {
; |& a! i) @3 b: X; A" M0 k    console.log(entry);
5 c: L9 H8 E$ U) h4 z* R" @" ~4 c}
// logs ["a", 1]
2 x. |. D! K( K( `+ z$ r// logs ["b", 2]
// logs ["c", 3]

// 迭代map获取键值
, R2 n& [/ r6 b2 Zfor (let [key, value] of iterable) {
    console.log(key)
    console.log(value);
}

6 z5 t3 e2 U( d/ e9 X
// 迭代set
let iterable = new Set([1, 1, 2, 2, 3, 3,4]);
# a7 D6 M2 J* i3 i$ V: _+ Ufor (let value of iterable) {
) ~, i. ~9 E9 M# F# I" \# Z/ X    console.log(value);
}
// logs 1
9 r* G# k, F0 w7 S// logs 2
// logs 3
0 _+ L9 X) \- J// logs 4
; ]3 v" W) ?  [$ b; L
// 迭代 DOM 节点
let articleParagraphs = document.querySelectorAll('.article > p');
for (let paragraph of articleParagraphs) {
5 j) ?( L0 ~1 K, w" a" e    paragraph.classList.add("paragraph");
    // 给class名为“article”节点下的 p 标签添加一个名为“paragraph” class属性。
: Y5 K( B7 o- D* Q}

& c# ^. f' B3 S6 Q) Y# @8 V5 J// 迭代arguments类数组对象
% {" B7 w  O8 u% ]7 [3 g. E(function() {
  for (let argument of arguments) {
    console.log(argument);
3 W; b/ r) d! r9 s# `- x! g  }
})(1, 2, 3);
// logs：
// 1
// 2
" ^  E* P; }. g, H' ^+ |! n/ G// 3

- ?, D1 [; k! ^" r9 N( f
// 迭代类型数组
  S) c1 N+ z+ T+ }: Vlet typeArr = new Uint8Array([0x00, 0xff]);
3 Q* C2 ^# |6 H; t% [8 y- x" ?for (let value of typeArr) {
4 k& n0 w: Z+ R) r0 ?: @; m7 j  console.log(value);
}
// logs：
// 0
% M5 O& Z* G6 G5 Q5 f// 255

& p2 c; l6 |6 f' T
9 d2 L8 l- ]6 T. i- y经过第一轮的自我介绍和技能展示后，我们了解到:

• for语句是最原始的循环语句。定义一个变量i(数字类型，表示数组的下标),按照一定的条件，对i进行循环累加。条件通常为循环对象的长度，当超过长度就停止循环。因为对象无法判断长度，所以搭配Object.keys()使用。
• forEach ES5 提出。自称是for语句的加强版，可以发现它比for语句在写法上简单了很多。但是本质上也是数组的循环。forEach每个数组元素执行一次 callback 函数。也就是调用它的数组，因此，不会改变原数组。返回值是undefine。
• map  ES5 提出。给原数组中的每个元素都按顺序调用一次  callback 函数。生成一个新数组，不修改调用它的原数组本身。返回值是新的数组。
• for...in  ES5 提出。遍历对象上的可枚举属性，包括原型对象上的属性，且按任意顺序进行遍历，也就是顺序不固定。遍历数组时把数组的下标当作键值，此时的i是个字符串型的。它是为遍历对象属性而构建的，不建议与数组一起使用。
• for...of ES6 提出。只遍历可迭代对象的数据。
  

能力甄别作为一个程序员，仅仅认识他们是远远不够的，在实际开发中鉴别他们各自的优缺点。因地制宜的使用他们，扬长避短。从而提高程序的整体性能才是能力之所在。关于跳出循环体在循环中满足一定条件就跳出循环体，或者跳过不符合条件的数据继续循环其它数据。是经常会遇到的需求。常用的语句是break 与 continue。简单的说一下二者的区别，就当复习好了。

• break语句是跳出当前循环，并执行当前循环之后的语句；
• continue语句是终止当前循环，并继续执行下一次循环;
  

注意：forEach 与map 是不支持跳出循环体的，其它三种方法均支持。
) t8 I" V9 K  m; ^) C, x原理 ：查看forEach实现原理，就会理解这个问题。

Array.prototype.forEach（callbackfn [，thisArg]{
7 |3 U/ `+ x9 b   
9 H, {9 M7 n% S- m6 Z& b2 e}
0 s# ^# R' O/ @( c5 F* V+ n传入的function是这里的回调函数。在回调函数里面使用break肯定是非法的，因为break只能用于跳出循环，回调函数不是循环体。
3 \6 k0 ?- u7 j' g, q" l在回调函数中使用return，只是将结果返回到上级函数，也就是这个for循环中，并没有结束for循环，所以return也是无效的。
map() 同理。
) O( E- ?; I0 I9 d/ rmap()链式调用
map() 方法是可以链式调用的，这意味着它可以方便的结合其它方法一起使用。例如：reduce(), sort(), filter() 等。但是其它方法并不能做到这一点。forEach()的返回值是undefined，所以无法链式调用。
1 q8 V% p8 W: X7 C
3 L( b/ ]3 w3 i3 ~' m// 将元素乘以本身，再进行求和。
let arr = [1, 2, 3, 4, 5];
let res1 = arr.map(item => item * item).reduce((total, value) => total + value);
$ o, r6 \7 S" x
console.log(res1) // logs 55 undefined"
* r/ t7 ]0 E5 r8 e, O$ ^, e. a
% S# o& T) e9 R' e2 U; A
for...in会遍历出原型对象上的属性

  ?' ?6 r  C6 w1 I7 ~2 W1 qObject.prototype.objCustom = function() {};
6 E; m# b# n" p  |6 s6 S$ Q' rArray.prototype.arrCustom = function() {};
! S( T! S4 Z' S3 i) M8 E( qvar arr = ['a', 'b', 'c'];
9 A$ v6 ~& |8 yarr.foo = 'hello
2 F& {# u4 d6 g; j% [4 qfor (var i in arr) {
    console.log(i);
}
// logs
2 M3 B6 B' b( b0 s// 0
) c8 D$ T# F2 O1 r4 m3 U// 1
& o. b0 [  Y* T8 f: V// 2
// foo
// arrCustom
4 W, {6 u/ i1 l# B0 `// objCustom


然而在实际的开发中，我们并不需要原型对象上的属性。这种情况下我们可以使用hasOwnProperty() 方法，它会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。如下：

/ j" B. m! I5 O% r, wObject.prototype.objCustom = function() {};
Array.prototype.arrCustom = function() {};
& N* d& O4 J4 Yvar arr = ['a', 'b', 'c'];
5 v; M) n/ C3 W3 I) s4 f: k/ Farr.foo = 'hello
for (var i in arr) {
    if (arr.hasOwnProperty(i)) {
        console.log(i);
! Y0 t6 F2 f& ], b    }
3 x! s/ T, U' `+ \- i% m& z+ E}
// logs
3 W& |+ u0 X6 ?7 [8 p6 T5 ?// 0
- y7 o6 R3 I. y* s4 v6 J// 1
8 O4 c+ E$ ^$ t// 2
// foo

) L7 u/ k, a" g" A, D& u" \// 可见数组本身的属性还是无法摆脱。此时建议使用 forEach
$ w: p  I: v. h% Z  S( C$ a对于纯对象的遍历，选择for..in枚举更方便；对于数组遍历，如果不需要知道索引for..of迭代更合适，因为还可以中断；如果需要知道索引，则forEach()更合适；对于其他字符串，类数组，类型数组的迭代，for..of更占上风更胜一筹。但是注意低版本浏览器的是配性。


性能
$ O! H" d. s" S% V" z( f9 |# M9 V有兴趣的读者可以找一组数据自行测试，文章就直接给出结果了，并做相应的解释。

for > for-of > forEach > map > for-in
% N  I- V% X' g6 H

• for 循环当然是最简单的，因为它没有任何额外的函数调用栈和上下文；
• for...of只要具有Iterator接口的数据结构，都可以使用它迭代成员。它直接读取的是键值。
• forEach，因为它其实比我们想象得要复杂一些，它实际上是array.forEach(function(currentValue, index, arr), thisValue)它不是普通的 for 循环的语法糖，还有诸多参数和上下文需要在执行的时候考虑进来，这里可能拖慢性能；
• map() 最慢，因为它的返回值是一个等长的全新的数组，数组创建和赋值产生的性能开销很大。
• for...in需要穷举对象的所有属性，包括自定义的添加的属性也能遍历到。且for...in的key是String类型，有转换过程，开销比较大。
  

8 z8 Y: S; O- Z3 E) P总结
在实际开发中我们要结合语义话、可读性和程序性能，去选择究竟使用哪种方案。如果你需要将数组按照某种规则映射为另一个数组，就应该用 map。如果你需要进行简单的遍历，用 forEach 或者 for of。如果你需要对迭代器进行遍历，用 for of。如果你需要过滤出符合条件的项，用 filterr。如果你需要先按照规则映射为新数组，再根据条件过滤，那就用一个 map 加一个 filter。总之，因地制宜，因时而变。千万不要因为过分追求性能，而忽略了语义和可读性。在您的统治之下，他们5个只能是各自发挥长处，谁都别想称霸。

3 t. l" z$ V  L" Z( }1 m* T