Wyjaśnienie generatorów w języku JavaScript

May 05 2023

W JavaScript funkcja generatora jest specjalnym rodzajem funkcji, którą można wstrzymywać i wznawiać podczas wykonywania. Oznacza to, że generator może generować wiele wartości w czasie, zamiast zwracać tylko jedną wartość, jak zwykła funkcja.

W JavaScript funkcja generatora jest specjalnym rodzajem funkcji, którą można wstrzymywać i wznawiać podczas wykonywania. Oznacza to, że generator może generować wiele wartości w czasie, zamiast zwracać tylko jedną wartość, jak zwykła funkcja.

Funkcje generatora są deklarowane przy użyciu składni funkcji* (lub starszej składni ze słowem kluczowym function, po którym następuje generator słów w nawiasach). Kiedy wywoływana jest funkcja generatora, tak naprawdę nie zaczyna ona działać natychmiast. Zamiast tego zwraca obiekt iteratora, którego można użyć do sterowania wykonaniem generatora.

Oto przykład prostej funkcji generatora:

function* generateSequence() {
  yield 1;
  yield 2;
  yield 3;
}

Aby użyć generatora, najpierw tworzymy obiekt iteratora, wywołując funkcję generatora:

const iterator = generateSequence();

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 }

Gdy generator zakończy zwracanie wartości, automatycznie zwraca { wartość: niezdefiniowana, zrobione: prawda }.

Generatory mogą również otrzymywać wartości wejściowe od wywołującego za pomocą słowa kluczowego yield. Oto przykład generatora, który otrzymuje wartość początkową i generuje sekwencję wartości, które są dwa razy większe niż poprzednia wartość:

function* generateDoubles(start) {
  let current = start;
  while (true) {
    yield current;
    current *= 2;
  }
}

const iterator = generateDoubles(1);

console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 4, done: false }
console.log(iterator.next()); // { value: 8, done: false }

Generatory są często używane do implementacji iteratorów dla niestandardowych struktur danych. Oto przykład generatora, który iteruje po kluczach obiektu:

const myObject = { a: 1, b: 2, c: 3 };

function* generateKeys(obj) {
  for (let key in obj) {
    yield key;
  }
}

const iterator = generateKeys(myObject);
console.log(iterator.next()); // { value: "a", done: false }
console.log(iterator.next()); // { value: "b", done: false }
console.log(iterator.next()); // { value: "c", done: false }
console.log(iterator.next()); // { value: undefined, done: true }

Generatorów można również użyć do implementacji leniwej oceny, w której wartości są obliczane tylko wtedy, gdy są faktycznie potrzebne. Oto przykład generatora, który generuje liczby pierwsze na żądanie:

function* generatePrimes() {
  let current = 2;
  while (true) {
    if (isPrime(current)) {
      yield current;
    }
    current++;
  }
}

function isPrime(num) {
  for (let i = 2; i < num; i++) {
    if (num % i === 0) {
      return false;
    }
  }
  return num !== 1;
}

const iterator = generatePrimes();
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: 5, done: false }
console.log(iterator.next()); // { value: 7, done: false }
console.log(iterator.next()); // { value: 11, done: false }

Generatory mogą być również używane do implementacji programowania asynchronicznego przy użyciu składni async/await. Oto przykład funkcji generatora, która symuluje operację asynchroniczną, której ukończenie zajmuje zmienną ilość czasu:

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function* generateAsyncValues() {
  let count = 0;
  while (true) {
    await sleep(1000);
    yield count++;
  }
}

(async () => {
  const iterator = generateAsyncValues();
  console.log(await iterator.next()); // { value: 0, done: false }
  console.log(await iterator.next()); // { value: 1, done: false }
  console.log(await iterator.next()); // { value: 2, done: false }
  console.log(await iterator.next()); // { value: 3, done: false }
})();

Podsumowując, generatory w JavaScript są potężnym narzędziem do implementacji iteratorów, leniwej oceny i programowania asynchronicznego. Pozwalają funkcjom generować wiele wartości w czasie i mogą być wstrzymywane i wznawiane podczas wykonywania. Korzystając z generatorów, programiści mogą pisać bardziej wydajny, elastyczny i czytelny kod.

Dziękuje za przeczytanie!

Mam nadzieję, że ten artykuł był dla Ciebie przydatny. Jeśli masz jakieś pytania lub sugestie, zostaw komentarz. Twoja opinia pomaga mi stawać się lepszym.