diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/generator')
4 files changed, 454 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/generator/index.html b/files/fr/web/javascript/reference/objets_globaux/generator/index.html new file mode 100644 index 0000000000..3557fe4bb2 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/generator/index.html @@ -0,0 +1,135 @@ +--- +title: Generator +slug: Web/JavaScript/Reference/Objets_globaux/Generator +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator +--- +<div>{{JSRef}}</div> + +<p>L'objet <code><strong>Generator</strong></code> est renvoyé par une {{jsxref("Instructions/function*","fonction génératrice","",1)}}, c'est à la fois <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rateur_%C2%BB">un itérateur</a> et <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_%C2%AB_it%C3%A9rable_%C2%BB">un itérable</a>.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }"</pre> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("Generator.prototype.next()")}}</dt> + <dd>Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}.</dd> + <dt>{{jsxref("Generator.prototype.return()")}}</dt> + <dd>Renvoie la valeur donnée et termine le générateur.</dd> + <dt>{{jsxref("Generator.prototype.throw()")}}</dt> + <dd>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.</dd> +</dl> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Un_itérateur_infini">Un itérateur infini</h3> + +<pre class="brush: 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 +// ...</pre> + +<h2 id="Générateurs_historiques">Générateurs historiques</h2> + +<p>Firefox (SpiderMonkey) implémente également une version antérieure pour les générateurs avec <a href="/fr/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>. 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é <code>yield</code> 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(1083482)}}), il est fortement déconseillé de les utiliser.</p> + +<h3 id="Méthodes_pour_les_générateurs_historiques">Méthodes pour les générateurs historiques</h3> + +<dl> + <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt> + <dd>Renvoie une valeur générée par l'expression {{jsxref("Opérateurs/yield", "yield")}}. Cette méthode correspond à <code>next()</code> pour les générateurs ES2015.</dd> + <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt> + <dd>Clôture le générateur, tout appel ultérieur à <code>next()</code> renverra une exception {{jsxref("StopIteration")}}. Cela correspond à la méthode <code>return()</code> pour les générateurs ES2015.</dd> + <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt> + <dd>Utilisée pour envoyer une valeur à un générateur. La valeur est renvoyée avec une expression {{jsxref("Opérateurs/yield", "yield")}} et renvoie une valeur générée par la prochaine expression {{jsxref("Opérateurs/yield", "yield")}}. <code>send(x)</code> correspond à <code>next(x)</code> pour les générateurs ES2015.</dd> + <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt> + <dd>Lève une exception au sein d'un générateur. Cela correspond à la méthode <code>throw()</code> pour les générateurs ES2015.</dd> +</dl> + +<h3 id="Exemple_utilisant_un_générateur_historique">Exemple utilisant un générateur historique</h3> + +<pre class="brush: 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é) +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Generator")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<h3 id="Générateurs_historiques_2">Générateurs historiques</h3> + +<ul> + <li>{{jsxref("Instructions/Fonction_génératrice_historique", "Fonction génératrice historique", "", 1)}}</li> + <li>{{jsxref("Opérateurs/function*", "L'expression d'un générateur historique", "", 1)}}</li> + <li>{{jsxref("StopIteration")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_itérateur_historique">Le protocole itérateur historique</a></li> +</ul> + +<h3 id="Générateurs_ES2015">Générateurs ES2015</h3> + +<ul> + <li>{{jsxref("Fonctions", "Fonctions", "", 1)}}</li> + <li>{{jsxref("Instructions/function", "function")}}</li> + <li>L'expression {{jsxref("L_opérateur_function", "function")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Instructions/function*", "function*")}}</li> + <li>L'expression {{jsxref("Opérateurs/function*", "function*")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">Le protocole Iterator</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/generator/next/index.html b/files/fr/web/javascript/reference/objets_globaux/generator/next/index.html new file mode 100644 index 0000000000..059ebdac04 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/generator/next/index.html @@ -0,0 +1,116 @@ +--- +title: Generator.prototype.next() +slug: Web/JavaScript/Reference/Objets_globaux/Generator/next +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/next +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>next</strong></code><strong><code>()</code></strong> renvoie un objet possédant deux propriétés <code>done</code> et <code>value</code>. Cette méthode peut également recevoir un paramètre pour envoyer une valeur au générateur.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>gen</var>.next(<var>valeur</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>La valeur à envoyer au générateur. La valeur sera affectée comme résultat d'une expression <code>yield</code>. Autrement dit, lorsque le générateur contient une expression de la forme <code>variable = yield expression</code>, c'est l'argument <code>valeur</code> qui sera affecté à <code>variable</code><em>.</em></dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Object")}} possédant deux propriétés :</p> + +<ul> + <li><code>done</code> (un booléen) + + <ul> + <li>vaut <code>true</code> si l'itérateur a atteint la fin de la série sur laquelle il itère. Dans ce cas, la propriété <code>value</code> définit la valeur de retour pour l'itérateur.</li> + <li>vaut <code>false</code> si l'itérateur a pu fournir la prochaine valeur de la série. C'est la valeur par défaut si la propriété <code>done</code> n'est pas définie.</li> + </ul> + </li> + <li><code>value</code> - n'importe quelle valeur JavaScript renvoyée par l'itérateur. Cette propriété peut être absente lorsque <code>done</code> vaut <code>true</code>.</li> +</ul> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_next()">Utiliser <code>next()</code></h3> + +<p>L'exemple suivant illustre comment utiliser un générateur simple et les objets renvoyés par la méthode <code>next</code> :</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }" +g.next(); // "Object { value: 1, done: false }" +g.next(); // "Object { value: 2, done: false }" +g.next(); // "Object { value: 3, done: false }" +g.next(); // "Object { value: undefined, done: true }" +</pre> + +<h3 id="Envoyer_des_valeurs_à_un_générateur">Envoyer des valeurs à un générateur</h3> + +<p>Ici, <code>next</code> est appelé avec une valeur. On notera ici que le premier appel n'affiche rien car le générateur n'a encore rien généré.</p> + +<pre class="brush: js">function* gen() { + while(true) { + var value = yield null; + console.log(value); + } +} + +var g = gen(); +g.next(1); +// "{ value: null, done: false }" +g.next(2); +// 2 +// "{ value: null, done: false }" +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator.prototype.next', 'Generator.prototype.next')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.next', 'Generator.prototype.next')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div> +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Generator.next")}}</p> +</div> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Instructions/function*","function*")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Les itérateurs et générateurs</a></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/generator/return/index.html b/files/fr/web/javascript/reference/objets_globaux/generator/return/index.html new file mode 100644 index 0000000000..e67c07ad43 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/generator/return/index.html @@ -0,0 +1,102 @@ +--- +title: Generator.prototype.return() +slug: Web/JavaScript/Reference/Objets_globaux/Generator/return +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/return +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>return</strong></code><strong><code>()</code></strong> renvoie la valeur fournie et termine le générateur.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>gen</var>.return(<var>valeur</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>La valeur à renvoyer</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur fournie comme argument.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_return()">Utiliser <code>return()</code></h3> + +<p>L'exemple suivant illustre une utilisation simple d'un générateur et de la méthode <code>return()</code>.</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); + +g.next(); // { value: 1, done: false } +g.return("toto"); // { value: "toto", done: true } +g.next(); // { value: undefined, done: true } +</pre> + +<div class="note"> +<p><strong>Note : </strong>Si <code>done</code> vaut <code>true</code>, <code>return(valeur)</code> renverra la même chose que <code>next()</code> : <code>undefined</code>. Si aucun argument n'est fourni, la propriété <code>value</code> de l'objet renvoyé sera la même qu'avec un appel à <code>.next()</code>. Si un argument est fourni, c'est lui qui sera utilisé comme valeur pour l'attribut <code>value</code> du résultat.</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} +var g = gen(); +console.log(g.next()); // { value: 1; done: false} +console.log(g.next()); // { value: 2; done: false} +console.log(g.next()); // { value: 3; done: false} +console.log(g.next()); // { value: undefined; done: true} +console.log(g.return()); // { value: undefined; done: true} +console.log(g.return(1)); // { value: 1; done: true} + +</pre> +</div> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator.prototype.return', 'Generator.prototype.return')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.return', 'Generator.prototype.return')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Generator.return")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">function*</a></code></li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/generator/throw/index.html b/files/fr/web/javascript/reference/objets_globaux/generator/throw/index.html new file mode 100644 index 0000000000..efcc057257 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/generator/throw/index.html @@ -0,0 +1,101 @@ +--- +title: Generator.prototype.throw() +slug: Web/JavaScript/Reference/Objets_globaux/Generator/throw +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/throw +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>throw</strong></code><strong><code>()</code></strong> lève une erreur dans un générateur.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>gen</var>.throw(<var>exception</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>exception</code></dt> + <dd>L'exception à lever. On préfèrera généralement utiliser un objet qui est une instance d'{{jsxref("Error")}}.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un {{jsxref("Object")}} avec deux propriétés :</p> + +<ul> + <li><code>done</code> (un booléen) + + <ul> + <li>Qui vaut <code>true</code> lorsque l'itérateur a fini de parcourir la suite. Dans ce cas, <code>value</code> correspondra éventuellement à la valeur de retour de l'itérateur.</li> + <li>Qui vaut <code>false</code> si l'itérateur a pu produire la prochaine valeur de la série.</li> + </ul> + </li> + <li><code>value</code> : une valeur renvoyée par l'itérateur. Lorsque <code>done</code> vaut <code>true</code>, cette valeur peut être absente ou valoir <code>undefined</code>.</li> +</ul> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_throw()">Utiliser <code>throw()</code></h3> + +<p>Dans l'exemple suivant, on utilise un générateur simple et on génère une exception grâce à la méthode <code>throw()</code>. Une exception peut être interceptée avec un bloc {{jsxref("Instructions/try...catch","try...catch")}} usuel.</p> + +<pre class="brush: js">function* gen() { + while(true) { + try { + yield 42; + } catch(e) { + console.log("Erreur interceptée !"); + } + } +} + +var g = gen(); +g.next(); +// { value: 42, done: false } +g.throw(new Error("Quelque chose s'est mal passé")); +// "Erreur interceptée !" +// { value: 42, done: false } +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div> +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Generator.throw")}}</p> +</div> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Instructions/function*","function*")}}</li> +</ul> |