Come faccio a scrivere una funzione freccia denominata in ES2015?

Ho una funzione che sto cercando di convertire nella nuova sintassi della freccia in ES6 . È una funzione denominata:

function sayHello(name) {
    console.log(name + ' says hello');
}

C'è un modo per dargli un nome senza un'istruzione var:

var sayHello = (name) => {
    console.log(name + ' says hello');
}

Ovviamente, posso usare questa funzione solo dopo averla definita. Qualcosa di simile al seguente:

sayHello = (name) => {
        console.log(name + ' says hello');
    }

Esiste un nuovo modo per farlo in ES6 ?

Come faccio a scrivere una funzione freccia denominata in ES2015?

Lo fai come hai escluso nella tua domanda: lo metti sul lato destro di un assegnazione o inizializzatore di proprietà in cui la variabile o il nome della proprietà può ragionevolmente essere usato come nome dal motore JavaScript. Non c'è altro modo per farlo, ma farlo è corretto e completamente coperto dalle specifiche.

Per spec, questa funzione ha un vero nome, sayHello:

var sayHello = name => {
    console.log(name + ' says hello');
};

Questo è definito in Operatori di assegnazione> Semantica di runtime: valutazione in cui chiama l' SetFunctionNameoperazione astratta (quella chiamata è attualmente al passaggio 1.e.iii).

Analogamente, Runtime Semantics: PropertyDefinitionEvaluation chiama SetFunctionNamee quindi dà a questa funzione un nome vero:

let o = {
    sayHello: name => {
        console.log(`${name} says hello`);
    }
};

I motori moderni impostano il nome interno della funzione per affermazioni del genere già; Edge ha ancora il bit che lo rende disponibile come namenell'istanza della funzione dietro un flag di runtime.

Ad esempio, in Chrome o Firefox, apri la console Web ed esegui questo frammento:

"use strict";
let foo = () => { throw new Error(); };
console.log("foo.name is: " + foo.name);
try {
  foo();
} catch (e) {
  console.log(e.stack);
}

Su Chrome 51 e versioni successive e Firefox 53 e versioni successive (e Edge 13 e versioni successive con un flag sperimentale), quando lo esegui, vedrai:

foo.name è: foo
Errore
    su foo (http://stacksnippets.net/js:14:23)
    su http://stacksnippets.net/js:17:3

Nota il foo.name is: fooe Error...at foo.

Su Chrome 50 e precedenti, Firefox 52 e precedenti e Edge senza il flag sperimentale, lo vedrai invece perché non hanno Function#name(ancora) la proprietà:

foo.name è: 
Errore
    su foo (http://stacksnippets.net/js:14:23)
    su http://stacksnippets.net/js:17:3

Si noti che manca il nome foo.name is:, ma viene mostrato nella traccia dello stack. È solo che implementare effettivamente la name proprietà sulla funzione ha avuto una priorità inferiore rispetto ad alcune altre funzionalità ES2015; Chrome e Firefox lo hanno ora; Edge ce l'ha dietro una bandiera, presumibilmente non sarà molto più a lungo dietro la bandiera.

Ovviamente, posso usare questa funzione solo dopo averla definita

Corretta. Non esiste una sintassi di dichiarazione di funzione per le funzioni freccia, solo la sintassi dell'espressione di funzione e non esiste una freccia equivalente al nome in un'espressione di funzione denominata vecchio stile ( var f = function foo() { };). Quindi non c'è equivalente a:

console.log(function fact(n) {
    if (n < 0) {
        throw new Error("Not defined for negative numbers");
    }
    return n == 0 ? 1 : n * fact(n - 1);
}(5)); // 120

Devi dividerlo in due espressioni (direi che dovresti farlo comunque ) :

let fact = n => {
    if (n < 0) {
      throw new Error("Not defined for negative numbers.");
    }
    return n == 0 ? 1 : n * fact(n - 1);
};
console.log(fact(5));

Naturalmente, se si dispone di mettere questo in cui è richiesta una sola espressione, è sempre possibile ... utilizzare una funzione freccia:

console.log((() => {
    let fact = n => {
        if (n < 0) {
            throw new Error("Not defined for negative numbers.");
        }
        return n == 0 ? 1 : n * fact(n - 1);
    };
    return fact(5);
})()); // 120

Non sto dicendo che sia carino, ma funziona se hai assolutamente, positivamente bisogno di un unico wrapper di espressioni.

No. La sintassi della freccia è una scorciatoia per funzioni anonime. Le funzioni anonime sono, anzi, anonime.

Le funzioni nominate sono definite con la functionparola chiave.

Se per "nome" intendi che vuoi impostare la .nameproprietà della tua funzione freccia, sei fortunato.

Se una funzione freccia è definita sul lato destro di un'espressione di assegnazione, il motore prenderà il nome sul lato sinistro e lo utilizzerà per impostare la funzione freccia .name, ad es.

var sayHello = (name) => {
    console.log(name + ' says hello');
}

sayHello.name //=== 'sayHello'

Detto questo, la tua domanda sembra essere più "posso ottenere una funzione freccia per sollevare?". La risposta a questo è un grande "no", temo.

Sembra che ciò sarà possibile con ES7: https://babeljs.io/blog/2015/06/07/react-on-es6-plus#arrow-functions

L'esempio fornito è:

class PostInfo extends React.Component {
  handleOptionsButtonClick = (e) => {
    this.setState({showOptionsModal: true});
  }
}

Il corpo delle funzioni freccia ES6 condivide lo stesso lessico del codice che le circonda, il che ci dà il risultato desiderato a causa del modo in cui gli inizializzatori della proprietà ES7 sono definiti.

Nota che per far funzionare tutto questo con Babel avevo bisogno di abilitare la sintassi ES7 stage 0 più sperimentale. Nel mio file webpack.config.js ho aggiornato il caricatore di babele in questo modo:

{test: /\.js$/, exclude: /node_modules/, loader: 'babel?stage=0'},

In realtà sembra che un modo per nominare le funzioni freccia (almeno a partire da Chrome 77 ...) sia fare questo:

"use strict";
let fn_names = {};
fn_names.foo = () => { throw new Error(); };
console.log("foo.name is: " + foo.name);
try {
  foo();
} catch (e) {
  console.log(e.stack);
}

per scrivere la funzione freccia denominata puoi aggiungere l'esempio seguente, dove ho una classe denominata LoginClass e all'interno di questa classe ho scritto una funzione denominata freccia , denominata successAuth classe LoginClass {

    constructor() {

    }

    successAuth = (dataArgs)=> { //named arow function

    }

}

QUESTO È ES6

Sì, penso che ciò che cerchi sia qualcosa del genere:

const foo = (depth) => {console.log("hi i'm Adele")}
foo -> // the function itself
foo() -> // "hi i'm Adele"

È possibile saltare la parte della funzione e la parte della freccia per creare funzioni. Esempio:

 class YourClassNameHere{

   constructor(age) {
     this.age = age;
   }

   foo() {
     return "This is a function with name Foo";
   }

   bar() {
     return "This is a function with name bar";
   }

 }

let myVar = new YourClassNameHere(50);
myVar.foo();