function*

Exemple interactif

function* generator(i) {
  yield i;
  yield i + 10;
}

const gen = generator(10);

console.log(gen.next().value);
// Expected output: 10

console.log(gen.next().value);
// Expected output: 20

Il est galement possible de dfinir un gnrateur en utilisant le constructeur GeneratorFunction et une expression function*.

Syntaxe

function* nom([param1[, param2[,  paramN]]]) {
  instructions
}

nom

Le nom de la fonction.

paramN

Le nom d'un paramtre formel pass la fonction.

instructions

Les instructions qui constituent le corps de la fonction.

Description

Les gnrateurs sont des fonctions qu'il est possible de quitter puis de reprendre. Le contexte d'un gnrateur (les liaisons avec ses variables) est sauvegard entre les reprises successives.

Les gnrateurs, combins avec les promesses, sont des outils de programmation asynchrones puissants qui permettent de rduire les inconvnients causs par les callbacks (fonctions de rappel) et l'inversion de contrle.

Lorsqu'on appelle une fonction gnratrice, son corps n'est pas excut immdiatement, c'est un itrateur qui est renvoy pour la fonction. Lorsque la mthode next() de l'itrateur est appele, le corps de la fonction gnratrice est utilis jusqu' ce que la premire expression yield soit trouve. Cette expression dfinira la valeur renvoyer pour l'itrateur. Si on utilise yield*, on pourra dlguer la gnration des valeurs une autre fonction gnratrice. La mthode next() renvoie un objet dont la proprit value contient la valeur gnre et une proprit done qui indique si le gnrateur a produit sa dernire valeur ou non. Lorsqu'on appelle la mthode next() avec un argument, cela reprendra l'excution de la fonction gnratrice et remplacera la valeur de l'expression yield (l o l'excution avait t interrompue) avec la valeur de l'argument pass next().

On peut utiliser une instruction return dans un gnrateur. Lorsque cette instruction sera excute, le gnrateur sera termin (done vaudra true). La valeur renvoye par l'instruction return sera la valeur de terminaison du gnrateur. Une fois qu'un gnrateur est termin, il ne peut plus produire d'autres valeurs.

l'instar d'une instruction return, une exception leve l'intrieur du gnrateur entranera la terminaison du gnrateur sauf si cette exception est intercepte. Lorsqu'un gnrateur est termin, les appels suivants next() n'excuteront aucun code provenant du gnrateur, ils renverront simplement un objet de la forme {value: undefined, done: true}.

Exemples

Exemple simple

function* creerID() {
  var index = 0;
  while (true) {
    yield index++;
  }
}

var gen = creerID();

console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3

Exemple utilisant des arguments

function* logGenerator() {
  console.log(yield);
  console.log(yield);
  console.log(yield);
}

var gen = logGenerator();

// le premier appel  next excute la fonction depuis son
// dbut jusqu'au premier yield rencontr
gen.next();
gen.next("bretzel"); // bretzel
gen.next("california"); // california
gen.next("mayonnaise"); // mayonnaise

Exemple utilisant yield*

function* autreGenerateur(i) {
  yield i + 1;
  yield i + 2;
  yield i + 3;
}
function* generateur(i) {
  yield i;
  yield* autreGenerateur(i);
  yield i + 10;
}

var gen = generateur(10);

console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12
console.log(gen.next().value); // 13
console.log(gen.next().value); // 20

Utilisation de return

function* yieldAndReturn() {
  yield "Y";
  return "R";
  yield "inaccessible";
}

var gen = yieldAndReturn();

console.log(gen.next()); // { value: "Y", done: false }
console.log(gen.next()); // { value: "R", done: true }
console.log(gen.next()); // { value: undefined, done: true }

Utiliser un gnrateur comme proprit

const monObj = {
  *generator() {
    yield "a";
    yield "b";
  },
};

const gen = monObj.generator();

console.log(gen.next()); // { value: "a", done: false }
console.log(gen.next()); // { value: "b", done: false }
console.log(gen.next()); // { value: undefined, done: true }

Utiliser un gnrateur comme proprit calcule

class Toto {
  *[Symbol.iterator]() {
    yield 1;
    yield 2;
  }
}

const monObj = {
  *[Symbol.iterator]() {
    yield "a";
    yield "b";
  },
};

console.log(Array.from(new Toto())); // [1, 2]
console.log(Array.from(monObj)); // [ "a", "b"]

Les gnrateurs ne sont pas constructibles

function* f() {}
var obj = new f(); // lve une TypeError: f n'est pas un constructeur

Gnrateur dfini avec une expression

const toto = function* () {
  yield 10;
  yield 20;
};
const truc = toto();
console.log(truc.next()); // {value: 10, done: false}

Spcifications

Compatibilit des navigateurs

Voir aussi

• L'expression function*
• L'objet GeneratorFunction
• itrateur
• yield
• yield*
• L'objet Function
• Les dclarations de fonction
• Les expressions de fonction
• Les fonctions
• D'autres ressources disponibles sur le Web :
  • Regenerator un compilateur permettant de traduire des gnrateurs ES2015 en du code JavaScript bas sur ES5
  • Forbes Lindesay: Promises and Generators: control flow utopia JSConf EU 2013 (vido en anglais)
  • Task.js
  • Itrer de faon asynchrone sur des gnrateurs