Generator
=========

L'objet **`Generator`** est renvoyé par une fonction génératrice, c'est à la fois un itérateur et un itérable.

Syntaxe
-------


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
```

Méthodes
--------

`Generator.prototype.next()`

Renvoie une valeur générée par l'expression `yield`.

`Generator.prototype.return()`

Renvoie la valeur donnée et termine le générateur.

`Generator.prototype.throw()`

Lève une exception dans un générateur. Cette opération termine le générateur, sauf si l'exception est interceptée dans le générateur.

Exemple
-------

### Un itérateur infini


```js
function\* idMaker() {
  var index = 0;
  while (true) yield index++;
}

var gen = idMaker(); // "Generator { }"

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

Générateurs historiques
-----------------------

Firefox (SpiderMonkey) implémente également une version antérieure pour les générateurs avec JavaScript 1.7. Pour cette syntaxe, il n'y a pas besoin d'utiliser l'astérisque dans la déclaration de la fonction, il suffit d'utiliser le mot-clé `yield` dans le corps de la fonction. Les générateurs historiques sont une fonctionnalité dépréciée et seront supprimés à l'avenir (bug Firefox 1083482), il est fortement déconseillé de les utiliser.

### Méthodes pour les générateurs historiques

`Generator.prototype.next()` 
Non-standard

Renvoie une valeur générée par l'expression `yield`. Cette méthode correspond à `next()` pour les générateurs ES2015.

`Generator.prototype.close()` 
Non-standard

Clôture le générateur, tout appel ultérieur à `next()` renverra une exception `StopIteration`. Cela correspond à la méthode `return()` pour les générateurs ES2015.

`Generator.prototype.send()` 
Non-standard

Utilisée pour envoyer une valeur à un générateur. La valeur est renvoyée avec une expression `yield` et renvoie une valeur générée par la prochaine expression `yield`. `send(x)` correspond à `next(x)` pour les générateurs ES2015.

**`Generator.`**`prototype.`**`throw()`** 
Non-standard

Lève une exception au sein d'un générateur. Cela correspond à la méthode `throw()` pour les générateurs ES2015.

### Exemple utilisant un générateur historique


```js
function\* fibonacci() {
  var a = yield 1;
  yield a \* 2;
}

var it = fibonacci();
console.log(it); // "Generator { }"
console.log(it.next()); // 1
console.log(it.send(10)); // 20
console.log(it.close()); // undefined
console.log(it.next()); // throws StopIteration (le générateur est clôturé)
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

### Générateurs historiques

* Fonction génératrice historique
* L'expression d'un générateur historique
* `StopIteration`
* Le protocole itérateur historique
### Générateurs ES2015

* Fonctions
* `function`
* L'expression `function`
* `Function`
* `function*`
* L'expression `function*`
* `GeneratorFunction`
* Le protocole Iterator