关于javascript:ES6-迭代器简述

Iterator 是 ES6 引入的一种遍历机制，迭代器有两个外围概念：

迭代器是一个对立的接口，它的作用是使各种数据结构可被便捷地拜访，它是通过一个键为 Symbol.iterator 的办法来实现。
迭代器是用于遍历数据结构元素的指针（如数据库中的游标）。

迭代的过程如下：

通过 Symbol.iterator 创立一个迭代器，指向以后数据结构的起始地位
随后通过 next 办法进行向下迭代指向下一个地位，next 办法会返回以后地位的对象，对象蕴含了 value 和 done 两个属性，value 是以后属性的值，done 用于判断是否遍历完结
当 done 为 true 时则遍历完结

上面通过一个简略的例子进行阐明：

const items = ["zero", "one", "two"]; 
const it = items[Symbol.iterator]();  
it.next(); 
// {value: "zero", done: false} 
it.next(); 
// {value: "one", done: false} 
it.next(); 
// {value: "two", done: false} 
it.next(); 
// {value: undefined, done: true}

下面的例子，首先创立一个数组，而后通过 Symbol.iterator 办法创立一个迭代器，之后一直地调用 next 办法对数组外部项进行拜访，当属性 done 为 true 时拜访完结。

迭代器是协定（应用它们的规定）的一部分，用于迭代。该协定的一个要害个性就是它是程序的：迭代器一次返回一个值。这意味着如果可迭代数据结构是非线性的（例如树），迭代将会使其线性化。

以下是可迭代的值:

Array
String
Map
Set
Dom 元素（正在进行中）

咱们将应用 for…of 循环（参见下文的 for…of 循环）对数据结构进行迭代。

Array

数组 (Array) 和类型数组 (TypedArray) 他们是可迭代的。

for (let item of ["zero", "one", "two"]) {console.log(item); 
} 

// zero 
// one 
// two

String

字符串是可迭代的，但他们遍历的是 Unicode 码，每个码可能蕴含一个到两个的 Javascript 字符。

for (const c of 'z\uD83D\uDC0A') {console.log(c); 
} 

// z 
// \uD83D\uDC0A

Map

Map 次要是迭代它们的 entries，每个 entry 都会被编码为 [key, value] 的项，entries 是以确定的模式进行迭代，其程序是与增加的程序雷同。

const map = new Map(); 
map.set(0, "zero"); 
map.set(1, "one");  
for (let item of map) {console.log(item); 
} 

// [0, "zero"] 
// [1, "one"]

留神：WeakMaps 不可迭代

Set

Set 是对其元素进行迭代，迭代的程序与其增加的程序雷同

const set = new Set(); 
set.add("zero"); 
set.add("one");  
for (let item of set) {console.log(item);
} 

// zero 
// one

留神：WeakSets 不可迭代

arguments

arguments 目前在 ES6 中应用越来越少，但也是可遍历的

function args() {for (let item of arguments) {console.log(item);
    }
} 
args("zero", "one"); 

// zero 
// one

一般对象是由 object 创立的，不可迭代：

// TypeError 
for (let item of {}) {console.log(item); 
}

// Uncaught TypeError: {} is not iterable

for…of 是 ES6 新引入的循环，用于代替 for..in 和 forEach()，并且反对新的迭代协定。它可用于迭代惯例的数据类型，如 Array、String、Map 和 Set 等等。

Array

const nums = ["zero", "one", "two"];
for (let num of nums) {console.log(num); 
} 

// zero
// one
// two

const typedArray1 = new Int8Array(6); 
typedArray1[0] = 10; 
typedArray1[1] = 11;
for (let item of typedArray1) {console.log(item);
}

// 10
// 11
// 0
// 0
// 0
// 0

String

const str = "zero";  
for (let item of str) {console.log(item);
}

// z
// e
// r
// o

Map

let myMap = new Map(); 
myMap.set(0, "zero"); 
myMap.set(1, "one"); 
myMap.set(2, "two");  
// 遍历 key 和 value 
for (let [key, value] of myMap) {console.log(key + "=" + value);
}
for (let [key, value] of myMap.entries()) {console.log(key + "=" + value);
}  
// 只遍历 key 
for (let key of myMap.keys()) {console.log(key);
}  
// 只遍历 value 
for (let value of myMap.values()) {console.log(value);
}

Set

let mySet = new Set(); 
mySet.add("zero"); 
mySet.add("one"); 
mySet.add("two");  
// 遍历整个 set 
for (let item of mySet) {console.log(item);
}  
// 只遍历 key 值 
for (let key of mySet.keys()) {console.log(key);
}  
// 只遍历 value 
for (let value of mySet.values()) {console.log(value);
}  
// 遍历 key 和 value，两者会相等 
for (let [key, value] of mySet.entries()) {console.log(key + "=" + value);
}

of 操作数必须是可迭代，这意味着如果是一般对象则无奈进行迭代。如果数据结构相似于数组的模式，则能够借助 Array.from() 办法进行转换迭代。

const arrayLink = {
    length: 2, 
    0: "zero", 
    1: "one"
}
// 报 TypeError 异样 
for (let item of arrayLink) {console.log(item);
}  
// 失常运行 
for (let item of Array.from(arrayLink)) {console.log(item);
}
// output: 
// zero 
// one

let、const 和 var 用于 for..of

如果应用 let 和 const，每次迭代将会创立一个新的存储空间，这能够保障作用域在迭代的外部。

const nums = ["zero", "one", "two"];
for (const num of nums) {console.log(num);
} 
// 报 ReferenceError 
console.log(num);

从下面的例子咱们看到，最初一句会报异样，起因 num 的作用域只在循环体外部，内部有效。应用 var 则不会呈现上述情况，因为 var 会作用于全局，迭代将不会每次都创立一个新的存储空间。

const nums = ["zero", "one", "two"];
forv (var num of nums) {console.log(num);
} 
console.log(num);
// output: two

~ 本文完，感激浏览！

学习乏味的常识，结识乏味的敌人，塑造乏味的灵魂！

我是〖编程三昧〗的作者 隐逸王 ，我的公众号是『编程三昧』，欢送关注，心愿大家多多指教！

你来，怀揣冀望，我有墨香相迎！你归，无论得失，唯以余韵相赠！

常识与技能并重，内力和外功兼修，实践和实际两手都要抓、两手都要硬！

关于javascript:ES6-迭代器简述

Iterator

迭代过程

可迭代的数据结构

一般对象不可迭代

for…of 循环

迭代惯例数据类型

可迭代的数据结构