web-dev-qa-db-fra.com

Puis-je utiliser la syntaxe de la fonction flèche de ES6 avec des générateurs? (notation de flèche)

c'est à dire comment j'exprime ceci:

function *(next) {}

avec des flèches. J'ai essayé toutes les combinaisons possibles et je ne trouve aucune documentation à ce sujet.

(utilise actuellement le noeud v0.11.14)

javascriptnode.jsgeneratorecmascript-6arrow-functions
171
Ashley Coolman

Puis-je utiliser la syntaxe de la fonction flèche de ES6 avec des générateurs?

Tu ne peux pas. Pardon. 

Selon MDN

L'instruction function* (mot-clé function suivi d'un astérisque) définit une fonction génératrice.

À partir d'un document spec (c'est moi qui souligne):

La syntaxe function est étendue pour ajouter un jeton * facultatif:

FunctionDeclaration: "function" "*"? Identifier "(" FormalParameterList? ")" 
  "{" FunctionBody "}"
154
user663031

La différence entre les fonctions Inline et Arrow

Tout d'abord, Arrow-functions _ () => {} ne sont pas conçus pour remplacer Inline-functions function(){} et ils sont différents . Inline-Functions sont simplement des fonctions. -Les fonctions sont.

Une expression de fonction de flèche (également appelée fonction de flèche) a une syntaxe plus courte que les expressions de fonction et ne lie pas sa propre this, arguments, super ou new.target). Les fonctions de flèche sont toujours anonymes.

Quelques détails plus rapides ici

Pourquoi la fonction Arrow ne peut pas être utilisée comme générateur

(https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Functions/Arrow_functions } _

Utilisation du mot-clé rendement

Le mot clé rendement ne peut pas être utilisé dans le corps d'une fonction de flèche (sauf si cela est autorisé dans les fonctions imbriquées dans celui-ci). En conséquence, les fonctions de flèche ne peuvent pas être utilisées comme générateurs.

Notez que générateurs sans yield n'ont pas de sens.

Pourquoi la fonction flèche ne peut pas utiliser le rendement

_ { http://tc39wiki.calculist.org/es6/arrow-functions/

Les fonctions de flèche lient this de manière lexicale, lient return dans le corps du corps Block de sorte qu'il retourne de la fonction de flèche immédiatement englobante, et exclut break et continue de faire référence à des instructions en dehors de la fonction de flèche immédiatement enveloppante. 

L'expression primaire Identifierarguments ne peut pas être utilisée dans le corps d'une fonction de flèche (que ce soit sous forme d'expression ou sous forme de bloc). 

De même, yield ne peut pas être utilisé dans le corps d'une fonction de flèche. Les flèches ne peuvent pas être génératrices et nous ne voulons pas de continuations profondes. 

Le rendement dans une fonction flèche générera une erreur sémantique: http://www.ecma-international.org/

En fin de compte, la raison réside dans la profonde complexité de la mise en œuvre d'ECMA6. C # ne le permet pas aussi bien pour un peu similaire raisons .

96
CoderPi

Outre les discussions sur les { esdiscuss.org } et notes de la réunion du comité Ecma TC39 ES6 de novembre 2013 mentionnées ci-dessus, des flèches génératrices ont été revues lors des deux réunions ES7 de septembre 2016 [1 ] _ { [2] _. Après une discussion sur les avantages et les inconvénients de diverses syntaxes (principalement =*> et =>*) et le manque de justifications et de cas d'utilisation de cette fonctionnalité, ils ont conclu que:

  • Le comité est intéressé, mais craint que la fonctionnalité ne tire pas son poids de l'ajout d'une nouvelle syntaxe.
  • Prévoyez de revenir le jour 3 pour voir si nous pouvons obtenir au moins =>* au stade 0, dans le cadre de la proposition d'itération asynchrone de Domenic Denicola.

La proposition de flèches de générateur a été déplacée à la phase 1 avec Brendan Eich et Domenic Denicola en tant que champions, mais un rapport pertinent { tc39/propositions } _ n'existe pas encore. Je suppose que pour plus d'informations, il faut attendre la finalisation de la proposition d'itération asynchrone d'étape 3.

22
monk-time

Je sais que c'est très tard, mais une autre raison possible pourrait être la syntaxe. Peut-être que (*() => {}) fonctionne, mais qu'en est-il de (9 ** () => {})? Est-ce que 9 est à la puissance d'une fonction de flèche, retournant NaN, ou est-ce 9 fois une fonction de flèche génératrice, retournant également NaN? Cela pourrait être fait avec une syntaxe alternative, telle que =>* comme mentionné par une autre réponse ici, mais peut-être souhaitait-il préserver la cohérence de la syntaxe de la fonction du générateur (par exemple, function* () {} et { *genMethod() {} }) lors de son implémentation. Pas trop une excuse, mais une raison pour cela.

2
coolreader18

J'avais aussi la même question et suis venu ici. Après avoir lu les posts et les commentaires, j’ai eu l’impression que l’utilisation de générateur dans une fonction flèche semblait vague:

const generator = () => 2*3; // * implies multiplication
// so, this would be a confusing
const generator = () =>* something; // err, multiplying?
const generator = () =*> ... // err, ^^
const generator = ()*=> ... // err, *=3, still multiplying?
const generator=*()=> ... // err, ^^
const generator = *param => ... //err, "param" is not fixed Word

C'est peut-être la principale raison pour laquelle ils n'ont pas implémenté le générateur en relation avec la fonction flèche.

Mais si j'étais l'un d'entre eux, j'aurais pu penser comme ceci:

const generator = gen param => ... // hmm, gen indicates a generator
const generator = gen () => ... // ^^

Cela ressemble à une fonction asynchrone:

const asyncFunction = async () => ... // pretty cool

Parce que, avec une fonction normale, le mot-clé async existe, la fonction flèche l'utilise donc - async () => est susceptible de paraître async function().

Mais il n'y a pas de mot clé comme gen ou generator et hélas, la fonction de flèche ne l'utilise pas.

De conclure:

Même s'ils souhaitent implémenter le générateur dans la fonction arrow, je pense qu'ils doivent repenser la syntaxe du générateur dans le noyau js:

generator function myfunc() {}
// rather than
function* myfunc() {} // or, function *myfunc() {}

Et ce sera une grosse erreur. Donc, garder la flèche en dehors du générateur, c'est plutôt cool.

Après commentaire @Bergi :

Les fonctions de flèche sont supposées être légères (et n'ont pas de prototype. Par exemple) et souvent à une seule ligne, alors que les générateurs sont à peu près le contraire.

Je dirai que le but du générateur à utiliser est run-stop-run et je ne pense donc pas que nous devions nous préoccuper du prototype, du lexical, etc.

1
Bhojendra Rauniyar

Il existe une solution de contournement de Nice avec redux-saga

import { call, all } from 'redux-saga/effects';

function* gen() {
   yield all([].map(() => {
      return call(....);
   }));
}
0
Julius Baltrušaitis