ローズマリーモードから反復プロトコルへ

ローズマリーモード
ローズマリーモードとは、オブジェクトの内部表現を露出することなく、1つの統合されたオブジェクトのそれぞれの要素に順次アクセスする方法を提供することである.
ローズマリーは内部ローズマリーと外部ローズマリーに分けられます.内部ローズマリーは一回の初期起動だけで、外部のローズマリーは次の要素を明示的に繰り返して要求しなければなりません.そうすると、手動で反復プロセスを制御できます.
内部ローズマリーを実行します.

Array.prototype.innerIterator = function(callback){
    for (let i = 0, len = this.length; i < len; i++) {
        callback && callback.call(this[i], this[i], i)
    }
};
[1,2,3].innerIterator(function(item, index){
    console.log('item:', item, 'index:', index)
})
// item: 1 index: 0
// item: 2 index: 1
// item: 3 index: 2

外部のローズマリーを実行します.

Array.prototype.outerInterator = function(){
    let index = 0;
        return {
            next: () => {
                return index < this.length ?
                {value: this[index++], done: false}:
                {value: undefined, done: true}
            }
    }
}
let iterator = [1,2,3].outerInterator();

for(let next; (next = iterator.next()) && !next.done;) {
    console.log('item', next.value)
}
// item 1
// item 2
// item 3

反復プロトコル
シーズマリーモードを了解しました.ES 6に追加されている反復プロトコルを見に来てください.反復可能なプロトコルとシーケンサプロトコル.
反復可能なプロトコル:1つの反復可能なオブジェクト(またはそのプロトタイプ)には、1つのSymbol.iteratorの属性が必要であり、この属性に対応する値は、1つのオブジェクトの無参照関数を返すものであり、リターンされたオブジェクトは、サブコマンダープロトコルに適合する.反復可能なオブジェクトが反復を必要とする場合、この方法を呼び出します.
いくつかのデータタイプは、自分のデフォルトの反復動作を持つ@@iterator方法を内蔵している.(String,Aray,TypedAray,Map,Setなどは、それぞれのプロトタイプオブジェクトが一つの@@iterator方法を持っているので、反復可能なオブジェクトを内蔵している.)

let iterator = ('hi')[Symbol.iterator]()
var a = iterator.next();
// a { value: 'h', done: false }

ディケンサプロトコル:1つのディケンサは、[Symbol.iterator]方法を実装しなければならない.この方法は、1つのオブジェクトの無参照関数を返すことである.返されるオブジェクトには、2つの必要な属性があります.doneとvalue.

Array.prototype.Iteration = function(){
    let index = 0;
        return {
            [Symbol.iterator](){return this},
            next: () => {
                return index < this.length ?
                {value: this[index++], done: false}:
                {value: undefined, done: true}
            }
    }
};
let Iteration = [2, 3, 4].Iteration();
for(let value of Iteration) {
    console.log('value', value)
}
// value 2
// value 3
// value 4

イテレーションは反復可能プロトコルと反復プロトコルを同時に満たすことができないことが分かった.また、反復可能なので、@@iteratorは直接使用可能であり、これは外部のローズマリーと非常に似ている.
データ構造がnext()方法を有すると、反復可能であると考えられる.ES 6の多くの新しい方法は、これに基づくfor...of、@@iterator、 、 、yield*などである.
以上の知識を知ったら、なぜ相手が直接for..ofを使ってはいけないのかが分かります.しかし、オブジェクトプロトタイプにArray.from()方法を追加して反復可能にすることができます.

Object.prototype.Iteration = function(){
    let keys = Object.keys(this), index = 0;
        return{
            [Symbol.iterator](){return this},
            next: () => {
                let current = index++;
                return current < keys.length?
                {value: [keys[current], this[keys[current]]], done: false}:
                {value: undefined, done: true};
            }
        }
}
let iterator = {'a': 1, 'b': 2, 'c': 3}.Iteration();
    for(let [key, value] of iterator) {
        console.log('key:', key, 'value:', value)
}
// key: a value: 1
// key: b value: 2
// key: c value: 3

生成器
以上のようなオブジェクトはすべて私たち自身が手動で実現し、反復可能なプロトコルと反復プロトコルに適合するオブジェクトです.面倒そうに見えますが、これらの仕事はもう私達のために関数ができました.それはジェネレータ関数です.
ジェネレータ関数は、サブジェネレータ工場の関数として使用でき、実行されると新しいGeneratorオブジェクトを返します.オブジェクトは反復可能なプロトコルとサブジェネレータプロトコルに適合しています.
今はジェネレータ関数を使って、オブジェクトを反復プロトコルに適合させます.

Object.prototype.Iteration = function *(){
    for(let [key, value] of Object.entries(this)){
        yield [key, value]
    }
}
for(let [key, value] of {'a': 1, 'b': 2, 'c': 3}.Iteration()) {
    console.log('key:', key, 'value:', value)
}
// key: a value: 1
// key: b value: 2
// key: c value: 3

ここでジェネレータは、ローズマリーとしてだけです.実は、まだメッセージ双方向システムです.これらの特性も存在しており、非同期プロセス制御はまた大きな一歩を踏み出した.