Kan ik de syntaxis van de pijlfunctie van ES6 gebruiken met generatoren? (pijlnotatie)

Dat wil zeggen, hoe spreek ik uit

function *(next) {}

met pijlsyntaxis? Ik heb alle combinaties geprobeerd die ik kon bedenken, en ik kan er geen documentatie over vinden.

(Ik gebruik momenteel Node.js v0.11.14.)

Antwoord 1, autoriteit 100%

Kan ik de syntaxis van de pijlfunctie van ES6 gebruiken met generatoren?

Dat kan niet. Sorry.

Volgens MDN

De function*-instructie (functiontrefwoord gevolgd door een asterisk) definieert een generatorfunctie.

Van een spec document(mijn nadruk):

De functiesyntaxis is uitgebreid om een ​​optioneel *token toe te voegen:

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

Antwoord 2, autoriteit 52%

Het verschil tussen Inline-functies en Arrow-functies

Allereerst Pijl-functies() => {}zijn niet gemaakt om Inline-functies function(){}te vervangen en ze zijn verschillend.
Inline-functies zijn gewoon functies, dus de vraag is wat het verschil is tussen Arrow-functies en Inline-functies.

Een pijlfunctie-uitdrukking (ook bekend als pijlfunctie) heeft een kortere syntaxis in vergelijking met functie-uitdrukkingen en bindt zijn eigen this, arguments, super, of new.target). Pijlfuncties zijn altijd anoniem.

Wat meer snelle details hier

Waarom de pijlfunctie niet als generator kan worden gebruikt

https://developer.mozilla.org/ nl/docs/Web/JavaScript/Reference/Functions/Arrow_functions

Gebruik van het rendementszoekwoord

Het rendement-zoekwoord is mogelijk niet gebruikt in de hoofdtekst van een pijlfunctie (behalve wanneer toegestaan ​​binnen functies die er verder in zijn genest). Als gevolg hiervan kunnen pijlfuncties niet als generatoren worden gebruikt.

Merk op dat generatorenzonder yieldslaat nergens op.

Waarom de pijlfunctie geen opbrengst kan gebruiken

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

Pijlfuncties binden thislexicaal, binden returnin de Blockbody case zodat het terugkeert van de direct omsluitende pijlfunctie, en sluit breaken continuevan verwijzingen naar instructies buiten de onmiddellijk omsluitende pijlfunctie.

De Identifierprimaire expressie argumentsmag niet worden gebruikt in de hoofdtekst van een pijlfunctie (uitdrukking of blokvorm).

Evenzo mag yieldniet worden gebruikt in de hoofdtekst van een pijlfunctie. Pijlen kunnen geen generatoren zijn en we willen geen diepe voortzettingen.

Opbrengst in een pijlfunctie levert Semantische fout op: http://www.ecma-international.org/

Uiteindelijk ligt de reden in de diepe complexiteit van de implementatie van ECMA6. C# staat dit ook niet toe voor enigszins vergelijkbare redenen.

Antwoord 3, autoriteit 17%

In aanvulling op de discussie op esdiscuss.orgen de Ecma TC39 commissie ES6 vergadernotities van november 2013hierboven vermeld, werden generatorpijlen opnieuw bezocht in twee ES7-vergaderingen van september 2016 [1][2]. Na een discussie over de voor- en nadelen van verschillende syntaxis (voornamelijk =*>en =>*) en een gebrek aan rechtvaardigingen en use-cases voor deze functie, kwamen ze tot de conclusie dat:

• Er is enige interesse van de commissie, maar men maakt zich zorgen dat de functie niet zijn gewicht in de schaal legt voor het toevoegen van een nieuw stuk syntaxis
• Plan om op dag 3 opnieuw te bezoeken om te zien of we =>*op zijn minst naar fase 0 kunnen krijgen, als onderdeel van [Domenic Denicola]’s voorstel voor asynchrone iteratie

Het voorstel voor generatorpijlen is verplaatst naar Fase 1met Brendan Eich en Domenic Denicola als kampioenen. De hierboven genoemde Asynchrone iteratiewas voltooid en geïmplementeerdin 2018.

In oktober 2019 verscheen een officiële repo van Sergey Rubanovmet meer discussie over syntaxis en andere details.

Antwoord 4, autoriteit 4%

Ik had ook dezelfde vraag en kwam hier. Na het lezen van de berichten en opmerkingen, vond ik het gebruik van generator in een pijlfunctie vaag:

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

Dit is misschien de grote reden waarom ze de generator niet hebben geïmplementeerd in verband met de pijlfunctie.

Maar als ik een van hen was, had ik zo kunnen denken:

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

Dit voelt net alsof we een asynchrone functie hebben:

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

Omdat, met een normale functie het trefwoord asyncbestaat, dus de pijlfunctie het gebruikt – async () =>lijkt waarschijnlijk op async function().

Maar er is geen trefwoord zoals genof generatoren helaas gebruikt de pijlfunctie het niet.

Tot slot:

Zelfs als ze de generator in de pijlfunctie willen implementeren, denk ik dat ze opnieuw moeten nadenken over de generatorsyntaxis in core js:

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

En dit wordt een grote blunder. Dus het is best cool om de pijlfunctie buiten de generator te houden.

Volgende @Bergi commentaar:

Nee. Pijlfuncties worden verondersteld lichtgewicht te zijn (en hebben bijvoorbeeld geen .prototype) en vaak oneliners, terwijl generatoren vrijwel het tegenovergestelde zijn.

Ik zal zeggen dat het doel van de generator om te gebruiken run-stop-runis en dus denk ik niet dat we ons druk hoeven te maken over prototype, lexicale dit, enz.

Antwoord 5, autoriteit 2%

Op dit moment kan dat niet, maar in de toekomst misschien wel omdat TC39 voorstelvoor hetzelfde in oktober 2019, in fase 1.

Antwoord 6

Ik weet dat dit erg laat is, maar een andere mogelijke reden kan de syntaxis zijn. misschien werkt (*() => {}), maar hoe zit het met (9 ** () => {})? Is dat 9 tot de macht van een pijlfunctie, die NaNretourneert, of is het 9 keer een generatorpijlfunctie, die ook NaNteruggeeft? Het zou kunnen worden gedaan met een alternatieve syntaxis, zoals =>*zoals vermeld in een ander antwoord hier, maar misschien was er een wens om de consistentie van de syntaxis van de generatorfunctie te behouden (bijv. function* () {}en { *genMethod() {} }) toen het werd geïmplementeerd. Niet al te veel excuus, maar wel een reden ervoor.

Antwoord 7

Er is een goede oplossing met redux-saga

import { call, all } from 'redux-saga/effects';
function* gen() {
   yield all([].map(() => {
      return call(....);
   }));
}