JavaScript入門 反復処理イテレータの解説

const iterator = {
    next(){                        ※１
        return {                   ※２
            done: [ true | false ],※３
            value: 値              ※４
        }
    }
}

//イテレータを生成する関数
function getIterator( max ){
    let value = 0;                  //※1
    return {
        next(){
            if( value < max ){      //valueがmaxより小さいとき
                return {
                    done: false,    //doneがfalseの場合は反復処理の継続を表す
                    value: value++  //※1のvalueを値として設定してから+1行う
                }
            } else {
                return {
                    done: true      //doneがtrueになると、反復処理の終了を表す。
                }                   //また、このときイテレータが返す値（value）
            }                       //は一般的に使用しないため、valueプロパティは省略している
        }
    }
}
const iterator = getIterator( 3 );
console.log( iterator.next() );
>{ done: false, value:0 }
console.log( iterator.next() );
>{ done: false, value:1 }
console.log( iterator.next() );
>{ done: false, value:2 }
console.log( iterator.next() );
>{ done: true }             //4回目でdoneがtrueになる

function alphabetIterator( start = "a", end = "z"){
    if ( start > end ){
        throw "開始文字は終了文字より前のアルファベットを選んでください。";
    }
    //splitはStringオブジェクトのメソッドで引数で指定された文字で文字列を分割し、配列として返す
    //なお、空文字("")が渡された場合には文字列を1文字ずつ分割する
    const ALPHABET_ARRAY = "abcdefghijklmnoparstuvwxyz" . split("");  //アルファベットが1文字ずつ格納された配列を定義
    //ALPHABET_ARRAY = [ 'a', 'b', 'c',…, "z" ];

    const startIndex = ALPHABET_ARRAY.indexOf( start ); //startとendの文字を配列内で検索し、一致する要素のインデックスを取得
    const endIndex = ALPHABET_ARRAY.indexOf( end);
    const targetAlphabet = ALPHABET_ARRAY.slice( startIndex, endIndex + 1 ); //配列を指定の範囲で切り取り（endの文字も含めたいので+1する）

    return {
        next(){
            const alphabet = targetAlphabet.shift(); //配列のshiftメソッドで配列の先頭から1ずつ要素を取り出す
                                                     //取り出す要素がなくなったとき、shift()はundefinedを返す
            return {
                value: alphabet,                     //取り出された要素をValueとして返す
                done: alphabet ? false : true,       //alphabetがundefinedのとき、trueを返す
            }
        }
    }
}
const it = alphabetIterator( "c", "e" );
let nextValue = it.next();
while (){                       //doneがtrueのとき、whileループを抜ける
    console.log( nextValue );
    nextValue = it.next();      //次の値をnextValueに格納
}
>{ done: false, value: "c" }
>{ done: false, value: "d" }
>{ done: false, value: "e" }

オブジェクトに直接設定する場合
const iterableObject = {
    [ Symbol.iterator ]: function() { return イテレータ }
};

//ES6のメソッドの省略法
const iterableObject = {
    [ Symbol.iterator ]: () { return イテレータ }
}

コンストラクタ関数に設定する場合（Arrayの場合）
Array.prototype[ Symbol.iterator ] = function() { return イテレータ }

クラスに設定する場合
class IterableClass{
    [ Symbol.iterator ]() { return イテレータ }
}

const iterableObject = {
    [ Symbol.iterator ](){
        let value = 0;
        return {
            next(){
                if ( value > 2 ){
                    return { done: true };
                } else {
                    return {
                        done: false,
                        value: value++,
                    };
                }
            }
        };
    }
};
for ( const value of iterableObject ){
    console.log( value );
}

//イテレータの定義（渡された値を2倍する）
function doubleIterator() {
   let index = 0;
   let arry = this;     //インスタンスにアクセスするときはthisを使用

   return {
        next() {
        if ( index < arry.length ) {     //インデックスが配列の長さより小さい場合には反復処理を継続
            return {
                done: false,
                value: arry[ index++ ] * 2　//値を2倍にして返す
            }
        } else {
            return {
                done: true
            }
        }
      }
   }
}

for ( let item of [ 1,2,3 ] ){
    console.log( item );     //配列の要素がそれぞれitemに渡される
}
>1
>2
>3

Array.prototype[ Symbol.iterator ] = doubleIterator;  //既存のイテレータを上書き

for ( let item of [ 1,2,3 ] ){
    console.log( item );     //２倍された値がitemに渡される
}
>2
>4
>5