本文へ移動

k8o

お問い合わせ

255文字以内で入力してください

GitHub Issueからのお問い合わせもお待ちしております。

Blog

公開: 2025年4月21日(月)更新: 2026年11月9日(月)約25分で読めます

Iterator Helpersで配列にせずmapやfilterを使う

Iterator Helpersで、MapやSetのvalues()などのイテレータに、配列に変換せずmap・filter・take・reduceなどを直接使えます。遅延評価で必要な分だけ処理する動きと、各メソッドの使い方を説明します。

Newly availableIterator methods2025年〜
  • Chrome122
  • Edge122
  • Firefox131
  • Safari18.4

はじめに

Iterator Helpersは、mapやfilter、takeなどのメソッドをIteratorオブジェクトに足す機能です。MapやSetのvalues()、ジェネレータが返すイテレータを、配列にせずにそのまま加工できます。Safari 18.4が対応して、Baseline 2025に入りました。

要素が手元にそろっていて数も多くないときは、[...set.values()]やArray.from()で配列にしてから、配列のメソッドを使います。終わりの無いジェネレータや、大きな並びから先頭のいくつかだけを取り出す処理は、配列にすると全部を取り出し終えるまで先へ進めません。必要な分だけを取り出して止められるのが、Iterator Helpersです。

js
function* naturals() {
  let n = 0;
  while (true) yield n++;
}

console.log(naturals().filter((n) => n % 3 === 0).map((n) => n * n).take(4).toArray()); // [0, 9, 36, 81]

コンソールに貼ると[0, 9, 36, 81]が出ます。naturals()は0から1ずつ増える値を終わりなく返しますが、take(4)で4つ取った時点で止まります。

使えるメソッドは、map、filter、take、drop、flatMap、reduce、toArray、forEach、some、every、findと、静的メソッドのfromです。

複数のイテラブルを1つのイテレータにつなぐIterator.concat()は、Baseline 2026に入りました。

Iteratorオブジェクト

Iteratorオブジェクトは、データの並びを1つずつ取り出すオブジェクトです。next()を呼ぶたびに、次の値のvalueと、もう値が無いかを表すdoneを持つオブジェクトを返します。

組み込みのイテレータの多くは、Iteratorを継承しています。Array.prototype[Symbol.iterator]やMap.prototype.values、Set.prototype.valuesの結果は、どれもIteratorオブジェクトを継承しています。Intl.Segmenter.prototype.segmentの結果やNodeListは、それ自身はIteratorを継承していませんが、[Symbol.iterator]()で取り出したイテレータは継承しています。たとえば、document.querySelectorAll('a') instanceof Iteratorはfalse、document.querySelectorAll('a')[Symbol.iterator]() instanceof Iteratorはtrueです。

js
const iterator = [1, 2, 3][Symbol.iterator]();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

const str = 'hello';
for (const char of str[Symbol.iterator]()) {
  console.log(char); // 'h' 'e' 'l' 'l' 'o'
}

Iterator Helpers

これまでIteratorオブジェクトを加工するときは、for...ofで処理を書くか、配列にしてから配列のmapやfilterを使っていました。

js
const set = new Set([1, 2, 3]);
console.log([...set.values()].some((i) => i % 2 === 0)); // true

const segmenter = new Intl.Segmenter('ja', {
  granularity: 'grapheme',
});
[...segmenter.segment('あいうえお')].forEach((x) =>
  console.log(x.segment),
); // 'あ' 'い' 'う' 'え' 'お'

const nodeList = document.querySelectorAll('div');
Array.from(nodeList).forEach((x) => console.log(x.innerText)); // '...', '...'

[...set.values()]のように配列にすると、その時点で全部の値を取り出します。Iteratorオブジェクトの、呼ばれたときに次の値を取り出す性質を生かせません。

Iterator Helpersを使えば、配列にせずにそのまま呼べます。

js
const set = new Set([1, 2, 3]);
console.log(set.values().some((i) => i % 2 === 0)); // true

const segmenter = new Intl.Segmenter('ja', {
  granularity: 'grapheme',
});
segmenter
  .segment('あいうえお')
  [Symbol.iterator]()
  .forEach((x) => console.log(x.segment)); // 'あ' 'い' 'う' 'え' 'お'

const nodeList = document.querySelectorAll('div');
nodeList[Symbol.iterator]().forEach((x) => console.log(x.innerText)); // '...', '...'

Iteratorオブジェクトのまま扱うので、someやtakeは必要な分だけ値を取り出して止まります(forEachは全部を取り出します)。100万要素のSetから、mapとfilterを通した先頭の10個を取り出す処理で比べます。

js
const set = new Set(Array.from({ length: 1_000_000 }, (_, i) => i));
// 配列にしてから
[...set.values()].map((i) => i * 2).filter((i) => i % 3 === 0).slice(0, 10);
// Iterator Helpers
set.values().map((i) => i * 2).filter((i) => i % 3 === 0).take(10).toArray();

先頭の10個だけを取り出すときは、どのブラウザでもIterator Helpersの方がはっきり速くなります。一方で、take(10)を外して全部の要素を取り出すと、Iterator Helpersの方が遅くなります。全部の要素を使うなら、配列にしてから配列のメソッドを使う方が速いです。

使い方

next()を呼ぶと0から2までを順に返す、Iteratorオブジェクトに似たcounterで試します。createCounter()を呼ぶたびに、0から数え直すcounterを作ります。

js
const createCounter = () => ({
  count: 0,
  next() {
    if (this.count < 3) {
      return { value: this.count++, done: false };
    }
    return { value: undefined, done: true };
  },
});
const counter = createCounter();

counter.next()は、valueが2になるまで、doneがfalseのオブジェクトを返します。

js
console.log(counter.next()); // { value: 0, done: false }
console.log(counter.next()); // { value: 1, done: false }
console.log(counter.next()); // { value: 2, done: false }
console.log(counter.next()); // { value: undefined, done: true }

一度数え終わったcounterはdone: trueを返し続けるので、以降の例ではcreateCounter()で作り直してから使います。

from

fromは、Iteratorオブジェクトの静的メソッドです。引数に渡した反復可能なオブジェクトや、counterのようにnextメソッドを持つオブジェクトから、新しいIteratorオブジェクトを生成します。

counterはnextメソッドを持つだけで、Iteratorを継承しておらず、[Symbol.iterator]も持ちません。そのままではfor...ofで回せず、以後紹介するメソッドもありません。Iterator.fromで包むと、どちらも使えるようになります。

js
// for (const x of counter) {} はTypeErrorになる
const counterIter = Iterator.from(createCounter());
for (const x of counterIter) {
  console.log(x); // 0 1 2
}
console.log(counterIter instanceof Iterator); // true

このあとのメソッドは、Iterator.fromで包んでから呼びます。Set.prototype.values()の結果のように、もとからIteratorを継承しているものは包まなくても呼べます。

map

mapは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、新しいIteratorオブジェクトを返します。

js
const counterIter = Iterator.from(createCounter());
const mappedIter = counterIter.map((x) => x * 2);
console.log(mappedIter.next()); // { value: 0, done: false }
console.log(mappedIter.next()); // { value: 2, done: false }
console.log(mappedIter.next()); // { value: 4, done: false }
console.log(mappedIter.next()); // { value: undefined, done: true }

関数が呼ばれるのは、mapを呼んだときではなく、next()を呼んだときです。コールバックにconsole.logを入れると、呼ばれるタイミングが分かります。

js
const counterIter = Iterator.from(createCounter());
const mappedIter = counterIter.map((x) => {
  console.log(x);
  return x * 2;
});
console.log(mappedIter.next()); // 0 { value: 0, done: false }
console.log(mappedIter.next()); // 1 { value: 2, done: false }
console.log(mappedIter.next()); // 2 { value: 4, done: false }

console.logは、next()を呼ぶたびに1回ずつ出ます。ほかのメソッドも、ほとんどは同じようにnext()のたびに評価します。以下では、全部を取り出すメソッドと、取り出し方が分かりにくいメソッドだけ、その点を書きます。

filter

filterは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、真となる要素だけを含む新しいIteratorオブジェクトを返します。

js
const counterIter = Iterator.from(createCounter());
const filteredIter = counterIter.filter((x) => x % 2 === 0);
console.log(filteredIter.next()); // { value: 0, done: false }
console.log(filteredIter.next()); // { value: 2, done: false }
console.log(filteredIter.next()); // { value: undefined, done: true }

filterは、関数が偽を返した値を飛ばし、真になる値が出るまで取り出し続けます。

js
const counterIter = Iterator.from(createCounter());
const filteredIter = counterIter.filter((x) => {
  console.log(x);
  return x % 2 === 0;
});
console.log(filteredIter.next()); // 0 { value: 0, done: false }
console.log(filteredIter.next()); // 1 2 { value: 2, done: false }
console.log(filteredIter.next()); // { value: undefined, done: true }
take

takeは、Iteratorオブジェクトから指定した数の要素を取り出し、新しいIteratorオブジェクトを返します。

js
const counterIter = Iterator.from(createCounter());
const takenIter = counterIter.take(2);
console.log(takenIter.next()); // { value: 0, done: false }
console.log(takenIter.next()); // { value: 1, done: false }
console.log(takenIter.next()); // { value: undefined, done: true }
drop

dropは、Iteratorオブジェクトから指定した数の要素をスキップし、新しいIteratorオブジェクトを返します。

js
const counterIter = Iterator.from(createCounter());
const droppedIter = counterIter.drop(2);
console.log(droppedIter.next()); // { value: 2, done: false }
console.log(droppedIter.next()); // { value: undefined, done: true }
flatMap

flatMapは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、得られた値をフラットにした新しいIteratorオブジェクトを返します。

js
const counterIter = Iterator.from(createCounter());
const flatMappedIter = counterIter.flatMap((x) => [x, x * 2]);
console.log(flatMappedIter.next()); // { value: 0, done: false }
console.log(flatMappedIter.next()); // { value: 0, done: false }
console.log(flatMappedIter.next()); // { value: 1, done: false }
console.log(flatMappedIter.next()); // { value: 2, done: false }
console.log(flatMappedIter.next()); // { value: 2, done: false }
console.log(flatMappedIter.next()); // { value: 4, done: false }
console.log(flatMappedIter.next()); // { value: undefined, done: true }

関数が返した配列は、そのままvalueになるのではなく、要素が1つずつnext()のたびに返ります。

reduce

reduceは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、最終的な値を返します。

js
const counterIter = Iterator.from(createCounter());
const reducedValue = counterIter.reduce((acc, x) => {
  return acc + x;
}, 0);
console.log(reducedValue); // 3

reduceは、全部の要素を取り出してから値を返します。対象を絞るときは、先にtakeやdropを通します。

toArray

toArrayは、Iteratorオブジェクトの全ての要素を配列に変換します。

js
const counterIter = Iterator.from(createCounter());
const array = counterIter.toArray();
console.log(array); // [ 0, 1, 2 ]

toArrayも、全部の要素を取り出します。

forEach

forEachは、Iteratorオブジェクトの各要素に対して指定した関数を適用します。

js
const counterIter = Iterator.from(createCounter());
counterIter.forEach((x) => {
  console.log(x);
});
// 0
// 1
// 2

forEachも、全部の要素を取り出します。

some

someは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、真となる要素が1つでもあればtrueを返します。

js
const counterIter = Iterator.from(createCounter());
const hasEven = counterIter.some((x) => x % 2 === 0);
console.log(hasEven); // true

someは、真になる要素が見つかった時点で取り出すのをやめます。見つからなければ、最後まで取り出してfalseを返します。

js
const counterIter = Iterator.from(createCounter());
const hasOdd = counterIter.some((x) => {
  console.log(x);
  return x % 2 === 1;
});
console.log(hasOdd); // 0 1 true
every

everyは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、全ての要素が真であればtrueを返します。

js
const counterIter = Iterator.from(createCounter());
const allEven = counterIter.every((x) => x % 2 === 0);
console.log(allEven); // false

everyは、偽になる要素が見つかった時点で取り出すのをやめます。

js
const counterIter = Iterator.from(createCounter());
const allEven = counterIter.every((x) => {
  console.log(x);
  return x % 2 === 0;
});
console.log(allEven); // 0 1 false
find

findは、Iteratorオブジェクトの各要素に対して指定した関数を適用し、真となる要素を返します。

js
const counterIter = Iterator.from(createCounter());
const found = counterIter.find((x) => x === 1);
console.log(found); // 1

findは、真になる要素が見つかった時点で取り出すのをやめます。

js
const counterIter = Iterator.from(createCounter());
const found = counterIter.find((x) => {
  console.log(x);
  return x === 1;
});
console.log(found); // 0 1 1

おわりに

Iterator Helpersを使うと、MapやSetのvalues()やジェネレータを配列にせずに、mapやfilter、takeで加工できます。途中で止められる処理では必要な分だけ取り出すので速くなり、全部の要素を使う処理では配列にした方が速いこともあります。

読了率 0%
もくじ