遍历
记不住的地方
JavaScript 的早期版本，for...in循环是基于in运算符的。in运算符不管某个属性是对象自身的还是继承的，都会返回true
var obj = {};
'toString' in obj // true如果一个属性的enumerable为false，下面三个操作不会取到该属性。
● for..in循环
● Object.keys方法
● JSON.stringify方法
数组遍历
for...in，不推荐
var a = [1, 2, 3];
for (var i in a) {
console.log(a[i]);
}
// 1
// 2
// 3不仅会遍历数组所有的数字键，还会遍历非数字键
var a = [1, 2, 3];
a.foo = true;
for (var key in a) {
console.log(key);
}
// 0
// 1
// 2
// foowhile循环或for循环，arr.length
var a = [1, 2, 3];
// for循环
for(var i = 0; i < a.length; i++) {
console.log(a[i]);
}
// while循环
var i = 0;
while (i < a.length) {
console.log(a[i]);
i++;
}
var l = a.length;
while (l--) {
console.log(a[l]);
}map()
map()方法不会跳过undefined和null，但会跳过空位
var nums=[1,2,3]
nums.map(function (n){
return n+1;
});
// [2,3,4]
// 当前成员、当前位置和数组本身
nums.map(function (elem,index,arr){
return elem*index;
});
// [0,2,6]
// map()方法不会跳过undefined和null，但会跳过空位forEach()
forEach()方法不会跳过undefined和null，但会跳过空位
// 当前值、当前位置、整个数组。
function log(element, index, array) {
console.log('[' + index + '] = ' + element);
}
[2, 5, 9].forEach(log);
// [0] = 2
// [1] = 5
// [2] = 9
// forEach()方法不会跳过undefined和null，但会跳过空位Object遍历
Object.keys()--可枚举属性/Object.getOwnPropertyNames()--所有属性
Object.keys方法的参数是一个对象，返回一个数组。该数组的成员都是该对象自身的（而不是继承的）所有属性名
var obj = {
p1: 123,
p2: 456
};
Object.keys(obj) // ["p1", "p2"]Object.getOwnPropertyNames方法与Object.keys类似，也是接受一个对象作为参数，返回一个数组，包含了该对象自身的所有属性名。
var obj = {
p1: 123,
p2: 456
};
Object.getOwnPropertyNames(obj) // ["p1", "p2"]对于一般的对象来说，Object.keys()和Object.getOwnPropertyNames()返回的结果是一样的。只有涉及不可枚举属性时，才会有不一样的结果。Object.keys方法只返回可枚举的属性，Object.getOwnPropertyNames方法还返回不可枚举的属性名。
var a = ['Hello', 'World'];
Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]for...in
var obj = {a: 1, b: 2, c: 3};
for (var i in obj) {
console.log('键名：', i);
console.log('键值：', obj[i]);
}
// 键名： a
// 键值： 1
// 键名： b
// 键值： 2
// 键名： c
// 键值： 3ES6
for...in，自身和继承的可枚举属性不含Symbol属性
Object.keys()，自身的可枚举，不含继承和Symbol属性
Object.getOwnPropertyNames()，自身的所有，可枚举不可枚举都返回，不含Symbol属性
Object.getOwnPropertySymbols()，自身所有Symbol
Reflect.ownKeys()，自身的，不含继承
以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则。
● 首先遍历所有数值键，按照数值升序排列。
● 其次遍历所有字符串键，按照加入时间升序排列。
● 最后遍历所有 Symbol 键，按照加入时间升序排列。
Iterator
ES6 创造了一种新的遍历命令for...of循环
Iterator 接口的目的，就是为所有数据结构，提供了一种统一的访问机制，即for...of循环）。当使用for...of循环遍历某种数据结构时，该循环会自动去寻找 Iterator 接口。
一种数据结构只要部署了 Iterator 接口，就称这种数据结构是“可遍历的”（iterable）。
ES6 规定，默认的 Iterator 接口部署在数据结构的Symbol.iterator属性，或者说，一个数据结构只要具有Symbol.iterator属性，就可以认为是“可遍历的”（iterable）。
Symbol.iterator属性本身是一个函数，就是当前数据结构默认的遍历器生成函数。执行这个函数，就会返回一个遍历器。 至于属性名Symbol.iterator，它是一个表达式，返回Symbol对象的iterator属性，这是一个预定义好的、类型为 Symbol 的特殊值，所以要放在方括号内
原生具备 Iterator 接口的数据结构如下。
● Array
● Map
● Set
● String
● TypedArray
● 函数的 arguments 对象
● NodeList 对象
let arr = ['a', 'b', 'c'];
let iter = arr[Symbol.iterator]();
iter.next() // { value: 'a', done: false }
iter.next() // { value: 'b', done: false }
iter.next() // { value: 'c', done: false }
iter.next() // { value: undefined, done: true }for ...of
JavaScript 原有的for...in循环，只能获得对象的键名，不能直接获取键值。ES6 提供for...of循环，允许遍历获得键值。
var arr = ['a', 'b', 'c', 'd'];
for (let a in arr) {
console.log(a); // 0 1 2 3
}
for (let a of arr) {
console.log(a); // a b c d
}for...of循环调用遍历器接口，数组的遍历器接口只返回具有数字索引的属性。这一点跟for...in循环也不一样
let arr = [3, 5, 7];
arr.foo = 'hello';
for (let i in arr) {
console.log(i); // "0", "1", "2", "foo"
}
for (let i of arr) {
console.log(i); // "3", "5", "7"
}遍历 Set 结构和 Map 结构
首先，遍历的顺序是按照各个成员被添加进数据结构的顺序。
其次，Set 结构遍历时，返回的是一个值，而 Map 结构遍历时，返回的是一个数组，该数组的两个成员分别为当前 Map 成员的键名和键值。
var engines = new Set(["Gecko", "Trident", "Webkit", "Webkit"]);
for (var e of engines) {
console.log(e);
}
// Gecko
// Trident
// Webkit
var es6 = new Map();
es6.set("edition", 6);
es6.set("committee", "TC39");
es6.set("standard", "ECMA-262");
for (var [name, value] of es6) {
console.log(name + ": " + value);
}
// edition: 6
// committee: TC39
// standard: ECMA-262