前言
本篇内容将按照下图展开：
遍历Object
Object最常见的遍历方法方法就是使用 for...in...，但其有一定的局限性，比如只能遍历可枚举属性。虽然Object无法直接使用 for循环和 forEach，但是经过 Reflect.ownKeys/
Object.getOwnPropertyNames/
Object.getOwnPropertySymbols/ Object.keys等方法转换直接得到Object中key值的集合后，是可以通过 for循环和 forEach来遍历的。
比如现在有个对象，其中有3个属性，分别是 可枚举属性、 不可枚举属性和 Symbol属性
letperson={name :'xiaoming'}person[Symbol('sex')]='man';Object.defineProperty(person,'age',{value :18,writable:true,configurable:false,enumerable:false})
使用for...in...遍历
for(letkey inperson){
console.log('key : '+ key + ' , value : '+ person[key]);
}
输出结果：
使用Object.keys + for循环遍历
使用Object.getOwnPropertyNames + for循环遍历
letnames = Object.getOwnPropertyNames(person);
for(letindex = 0, length = names.length; index < length; index++){
letkey = names[index];
letvalue= person[key];
console.log('key : '+ key + ' , value : '+ value);
}
输出结果：
使用Object.getOwnPropertySymbols + for循环遍历
letsymbols = Object.getOwnPropertySymbols(person);
for(letindex = 0, length = symbols.length; index < length; index++){
letkey = symbols[index];
letvalue = person[key];
typeofkey === 'symbol'? key = Symbol.prototype.toString.call(key) : '';
console.log('key : '+ key + ' , value : '+ value);
}
输出结果：
使用Reflect.ownKeys + for循环遍历
letkeys = Reflect.ownKeys(person);
for(letindex = 0, length = keys.length; index < length; index++){
letkey = keys[index];
letvalue = person[key];
typeofkey === 'symbol'? key = Symbol.prototype.toString.call(key) : '';
console.log('key : '+ key + ' , value : '+ value);
}
输出结果：
遍历Array
遍历Array可以使用 for循环，也可以使用 for...in...和 for...of...，并且Array的原型中还有 forEach函数和 map函数可用来遍历Array对象。
测试数据：
letarr = ['item_1', 'item_2', 'item_3', 'item_4', 'item_5'];
输出结果：
使用for循环遍历
for(let index= 0, length= arr.length; index< length; index+= 1){
console.log('index : '+ arr[index]);
}
输出结果：
使用Array.prototype.forEach遍历
Array.prototype.forEach.call(arr, (value)=>{
console.log('value : '+ value);
})
输出结果：
使用Array.prototype.map遍历
Array.prototype.map.call(arr, (value)=>{
console.log('value : '+ value);
})
输出结果：
map方法会根据原数组中的每个元素调用函数后返回的数据创建一个新数组。
使用for...of...遍历
for(letvalueof arr){
console.log('value : '+ value);
}
输出结果：
遍历Map
遍历Map一般是两种，一是直接使用 for...of...或者 Map.prototype.forEach，二是通过 Map.prototype.entries/ Map.prototype.keys/ Symbol.iterator获取Map对象的迭代器，再通过 for...of...来遍历迭代器。
测试数据：
letmap = newMap();
map.set('key_1', 'value_1');
map.set('key_2', 'value_2');
map.set('key_3', 'value_3');
map.set('key_4', 'value_4');
map.set('key_5', 'value_5');
使用for...of...遍历
for(let[key, value] of map){
console.log('key : '+ key + ' value : '+ value);
}
输出结果：
使用Map.prototype.forEach遍历
Map.prototype.forEach.call(map, (value, key)=>{
console.log('key : '+ key + ' value : '+ value);
})
输出结果：
使用Map.prototype.entries + for...of...遍历
letiterator = Map.prototype.entries.call(map);
for(letitem ofiterator){
console.log('item : '+ item);
}
输出结果：
使用Symbol.iterator + for...of...遍历
let iterator2 = map[Symbol.iterator]();
for(let item of iterator2){
console.log('item : ' + item);}
输出结果：
遍历Set
遍历Set和遍历Map差不多，Map有的方法Set都有，但是有一个差别： Map是以键值对的形式去存储数据的，其中键是唯一；而Set存储的只有值，其值是唯一的 。
遍历Set一般也是两种，一是直接使用 for...of...或者 Set.prototype.forEach，二是通过 Set.prototype.values/ Symbol.iterator获取Map对象的迭代器，再通 for...of...来遍历迭代器
像 Set.prototype.entries/ Set.prototype.keys虽然也可以达到遍历Set对象的效果，但是由于其将value当做key，笔者感觉这两个方法与上文中 Map.prototype.entries/ Map.prototype.keys逻辑上差别不大，故而不再赘述。
测试数据：
letset= newSet();
set.add('value_1');
set.add('value_2');
set.add('value_3');
set.add('value_4');
set.add('value_5');
使用for...of...遍历
for(letitem ofset){
console.log('item : '+ item);
}
输出结果：
使用Set.prototype.forEach遍历
letiterator = Set.prototype.values.call(set);
for(letvalueof iterator){
console.log('value : '+ value);
}
输出结果：
letiterator = Set.prototype.values.call(set);
for(letvalueof iterator){
console.log('value : '+ value);
}
输出结果：
使用Symbol.iterator + for...of...遍历
let iterator2 = set[Symbol.iterator]();
for(let value of iterator2){
console.log('value : ' + value);}
输出结果：
尾言
笔者才疏学浅，慌忙之下难免有遗漏或是疏忽，如有错误之处，还望各位看官不吝赐教，笔者在此感谢。
