Domanda var functionName = function () {} vs function functionName () {}


Recentemente ho iniziato a gestire il codice JavaScript di qualcun altro. Sto correggendo bug, aggiungendo funzionalità e anche cercando di riordinare il codice e renderlo più coerente.

Lo sviluppatore precedente utilizza due metodi per dichiarare le funzioni e non riesco a capire se c'è una ragione dietro o no.

I due modi sono:

var functionOne = function() {
    // Some code
};
function functionTwo() {
    // Some code
}

Quali sono le ragioni per utilizzare questi due diversi metodi e quali sono i pro e i contro di ciascuno? C'è qualcosa che può essere fatto con un metodo che non può essere fatto con l'altro?


6052
2017-12-03 11:31


origine


risposte:


La differenza è questa functionOne è un'espressione di funzione e quindi viene definita solo quando viene raggiunta quella linea, mentre functionTwo è una dichiarazione di funzione ed è definita non appena viene eseguita la sua funzione o script circostante (a causa di) sollevamento ).

Ad esempio, un'espressione di funzione:

// TypeError: functionOne is not a function
functionOne();

var functionOne = function() {
  console.log("Hello!");
};

E una dichiarazione di funzione:

// Outputs: "Hello!"
functionTwo();

function functionTwo() {
  console.log("Hello!");
}

Ciò significa anche che non è possibile definire condizionatamente funzioni utilizzando le dichiarazioni di funzione:

if (test) {
   // Error or misbehavior
   function functionThree() { doSomething(); }
}

Quanto sopra effettivamente definisce functionThree indipendentemente dal testIl valore di - a meno che use strict è in effetti, nel qual caso si solleva semplicemente un errore.


4489
2017-12-03 11:37



Per prima cosa voglio correggere Greg: function abc(){} è anche ambito - il nome abc è definito nell'ambito in cui viene rilevata questa definizione. Esempio:

function xyz(){
  function abc(){};
  // abc is defined here...
}
// ...but not here

In secondo luogo, è possibile combinare entrambi gli stili:

var xyz = function abc(){};

xyz sarà definito come al solito, abc non è definito in tutti i browser, ma Internet Explorer non si basa su di esso definito. Ma sarà definito all'interno del suo corpo:

var xyz = function abc(){
  // xyz is visible here
  // abc is visible here
}
// xyz is visible here
// abc is undefined here

Se si desidera eseguire l'alias delle funzioni su tutti i browser, utilizzare questo tipo di dichiarazione:

function abc(){};
var xyz = abc;

In questo caso, entrambi xyz e abc sono alias dello stesso oggetto:

console.log(xyz === abc); // prints "true"

Un valido motivo per utilizzare lo stile combinato è l'attributo "nome" degli oggetti funzione ( non supportato da Internet Explorer ). Fondamentalmente quando si definisce una funzione come

function abc(){};
console.log(abc.name); // prints "abc"

il suo nome è automaticamente assegnato. Ma quando lo definisci

var abc = function(){};
console.log(abc.name); // prints ""

il suo nome è vuoto: abbiamo creato una funzione anonima e l'abbiamo assegnata ad alcune variabili.

Un altro buon motivo per utilizzare lo stile combinato è utilizzare un nome interno breve per riferirsi a se stesso, fornendo al contempo un nome lungo non in conflitto per gli utenti esterni:

// Assume really.long.external.scoped is {}
really.long.external.scoped.name = function shortcut(n){
  // Let it call itself recursively:
  shortcut(n - 1);
  // ...
  // Let it pass itself as a callback:
  someFunction(shortcut);
  // ...
}

Nell'esempio sopra possiamo fare lo stesso con un nome esterno, ma sarà troppo ingombrante (e più lento).

(Un altro modo per riferirsi a se stesso è usare arguments.callee, che è ancora relativamente lungo e non supportato in modalità rigorosa.)

Nel profondo, JavaScript tratta entrambe le affermazioni in modo diverso. Questa è una dichiarazione di funzione:

function abc(){}

abc qui è definito ovunque nell'ambito corrente:

// We can call it here
abc(); // Works

// Yet, it is defined down there.
function abc(){}

// We can call it again
abc(); // Works

Inoltre, è stato issato attraverso a return dichiarazione:

// We can call it here
abc(); // Works
return;
function abc(){}

Questa è un'espressione di funzione:

var xyz = function(){};

xyz qui è definito dal punto di assegnazione:

// We can't call it here
xyz(); // UNDEFINED!!!

// Now it is defined
xyz = function(){}

// We can call it here
xyz(); // works

La dichiarazione di funzione rispetto all'espressione di funzione è la vera ragione per cui c'è una differenza dimostrata da Greg.

Fatto divertente:

var xyz = function abc(){};
console.log(xyz.name); // Prints "abc"

Personalmente, preferisco la dichiarazione di "espressione di funzione" perché in questo modo posso controllare la visibilità. Quando definisco la funzione mi piace

var abc = function(){};

So che ho definito la funzione localmente. Quando definisco la funzione mi piace

abc = function(){};

So che l'ho definito globalmente a condizione che non l'avessi definito abc ovunque nella catena di ambiti. Questo stile di definizione è resiliente anche se usato all'interno eval(). Mentre la definizione

function abc(){};

dipende dal contesto e potrebbe lasciarti indovinare dove è effettivamente definito, specialmente nel caso di eval() - la risposta è: dipende dal browser.


1804
2017-12-03 17:43



Ecco il rundown sui moduli standard che creano funzioni: (Originariamente scritto per un'altra domanda, ma adattato dopo essere stato spostato nella domanda canonica).

Condizioni:

La lista veloce:

  • Dichiarazione delle funzioni

  • "Anonimo" function Espressione (che a dispetto del termine, a volte crea funzioni con nomi)

  • Di nome function Espressione

  • Accessor Function Initializer (ES5 +)

  • Arrow Function Expression (ES2015 +) (che, come le espressioni di funzioni anonime, non implicano un nome esplicito, e tuttavia possono creare funzioni con nomi)

  • Dichiarazione del metodo in Initializer oggetto (ES2015 +)

  • Costruttori e dichiarazioni di metodi in class (ES2015 +)

Dichiarazione delle funzioni

La prima forma è a dichiarazione di funzione , che assomiglia a questo:

function x() {
    console.log('x');
}

Una dichiarazione di funzione è a dichiarazione ; non è una dichiarazione o un'espressione. In quanto tale, non lo segui con a ; (anche se farlo è innocuo).

Una dichiarazione di funzione viene elaborata quando l'esecuzione entra nel contesto in cui appare, prima  qualsiasi codice passo-passo viene eseguito. La funzione che crea è data un nome proprio ( x nell'esempio sopra) e tale nome viene inserito nell'ambito in cui appare la dichiarazione.

Poiché viene elaborato prima di qualsiasi codice passo a passo nello stesso contesto, puoi fare cose come questa:

x(); // Works even though it's above the declaration
function x() {
    console.log('x');
}

Fino alla versione ES2015, le specifiche non riguardavano ciò che un motore JavaScript dovrebbe eseguire se si inserisce una dichiarazione di funzione all'interno di una struttura di controllo try, if, switch, whileecc. in questo modo:

if (someCondition) {
    function foo() {    // <===== HERE THERE
    }                   // <===== BE DRAGONS
}

E dal momento che sono elaborati prima  il codice passo-passo viene eseguito, è difficile sapere cosa fare quando si trovano in una struttura di controllo.

Sebbene questo non lo fosse specificato  fino a ES2015, era un estensione consentita  per supportare dichiarazioni di funzioni in blocchi. Sfortunatamente (e inevitabilmente), diversi motori hanno fatto cose diverse.

A partire da ES2015, le specifiche dicono cosa fare. In realtà, ci sono tre cose da fare:

  1. Se in modalità loose non  su un browser web, il motore JavaScript dovrebbe fare una cosa
  2. Se in modalità libera su un browser web, il motore JavaScript dovrebbe fare qualcos'altro
  3. Se in rigoroso  modalità (browser o meno), il motore JavaScript dovrebbe fare ancora un'altra cosa

Le regole per le modalità loose sono difficili, ma in rigoroso  modo, le dichiarazioni di funzione nei blocchi sono semplici: sono locali al blocco (hanno ambito di blocco , che è anche nuovo in ES2015), e sono issati in cima al blocco. Così:

"use strict";
if (someCondition) {
    foo();               // Works just fine
    function foo() {
    }
}
console.log(typeof foo); // "undefined" (`foo` is not in scope here
                         // because it's not in the same block)

"Anonimo" function Espressione

La seconda forma comune è chiamata a espressione di funzione anonima :

var y = function () {
    console.log('y');
};

Come tutte le espressioni, viene valutato quando viene raggiunto nell'esecuzione passo passo del codice.

In ES5, la funzione creata non ha nome (è anonimo). In ES2015, alla funzione viene assegnato un nome, se possibile, deducendolo dal contesto. Nell'esempio sopra, il nome sarebbe y. Qualcosa di simile è fatto quando la funzione è il valore di un inizializzatore di proprietà. (Per i dettagli su quando ciò accade e le regole, cercare SetFunctionName nel la specifica - sembra ovunque  il luogo.)

Di nome function Espressione

La terza forma è a chiamata espressione di funzione  ( "NPC"):

var z = function w() {
    console.log('zw')
};

La funzione che crea ha un nome proprio ( w in questo caso). Come tutte le espressioni, questo viene valutato quando viene raggiunto nell'esecuzione passo passo del codice. Il nome della funzione è non  aggiunto allo scope in cui appare l'espressione; il nome è  nell'ambito della funzione stessa:

var z = function w() {
    console.log(typeof w); // "function"
};
console.log(typeof w);     // "undefined"

Nota che le NFE sono state spesso fonte di bug per le implementazioni di JavaScript. IE8 e precedenti, ad esempio, gestiscono NFE completamente errato , creando due diverse funzioni in due momenti diversi. Le prime versioni di Safari presentavano anche problemi. La buona notizia è che le versioni correnti dei browser (IE9 e versioni successive, Safari corrente) non presentano più tali problemi. (Ma al momento della stesura di questo articolo, purtroppo, IE8 rimane in uso diffuso, e quindi usare NFE con il codice per il web in generale è ancora problematico.)

Accessor Function Initializer (ES5 +)

A volte le funzioni possono entrare di nascosto in gran parte inosservate; questo è il caso con funzioni accessorie . Ecco un esempio:

var obj = {
    value: 0,
    get f() {
        return this.value;
    },
    set f(v) {
        this.value = v;
    }
};
console.log(obj.f);         // 0
console.log(typeof obj.f);  // "number"

Si noti che quando ho usato la funzione, non l'ho usata ()! Questo perché è un funzione accessoria  per una proprietà. Otteniamo e impostiamo la proprietà nel modo normale, ma dietro le quinte, viene chiamata la funzione.

Puoi anche creare funzioni di accesso con Object.defineProperty, Object.definePropertiese il secondo argomento meno noto di Object.create.

Arrow Function Expression (ES2015 +)

ES2015 ci porta il funzione di freccia . Ecco un esempio:

var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); // 2, 4, 6

Guarda quello n => n * 2 cosa che si nasconde nel map() chiamata? Questa è una funzione.

Un paio di cose sulle funzioni della freccia:

  1. Non hanno il loro this. Invece, loro chiudere  il this del contesto in cui sono definiti. (Si chiudono anche sopra arguments e, se del caso, super.) Ciò significa che il this dentro di loro è lo stesso del this dove vengono creati e non possono essere modificati.

  2. Come avrai notato con quanto sopra, non usi la parola chiave function; invece, tu usi =>.

Il n => n * 2 l'esempio sopra è una forma di loro. Se hai più argomenti per passare la funzione, usi Parens:

var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); // 0, 2, 6

(Ricordatelo Array#map passa la voce come primo argomento e l'indice come seconda.)

In entrambi i casi, il corpo della funzione è solo un'espressione; il valore di ritorno della funzione sarà automaticamente il risultato di tale espressione (non si usa un esplicito return).

Se stai facendo più di una singola espressione, usa {} e un esplicito return (se è necessario restituire un valore), come normale:

var a = [
  {first: "Joe", last: "Bloggs"},
  {first: "Albert", last: "Bloggs"},
  {first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
  var rv = a.last.localeCompare(b.last);
  if (rv === 0) {
    rv = a.first.localeCompare(b.first);
  }
  return rv;
});
console.log(JSON.stringify(a));

La versione senza { ... } è chiamato una funzione di freccia con un corpo di espressione  o corpo conciso . (Anche un conciso  funzione di freccia.) Quello con { ... } definire il corpo è una funzione di freccia con a corpo della funzione . (Anche un verboso  funzione di freccia.)

Dichiarazione del metodo in Initializer oggetto (ES2015 +)

ES2015 consente una forma più breve di dichiarazione di una proprietà che fa riferimento a una funzione; sembra così:

var o = {
    foo() {
    }
};

l'equivalente in ES5 e precedenti sarebbe:

var o = {
    foo: function foo() {
    }
};

Costruttori e dichiarazioni di metodi in class (ES2015 +)

ES2015 ci porta class sintassi, compresi i costruttori e i metodi dichiarati:

class Person {
    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullName() {
        return this.firstName + " " + this.lastName;
    }
}

Ci sono due dichiarazioni di funzione sopra: Una per il costruttore, che ottiene il nome Persone uno per getFullName, a cui è assegnata una funzione Person.prototype.


544
2018-03-04 13:35



Parlando del contesto globale, entrambi, il var dichiarazione e a FunctionDeclaration alla fine creerà a non cancellabili  proprietà sull'oggetto globale, ma il valore di entrambi può essere sovrascritto .

La sottile differenza tra i due modi è che quando il Istanziazione variabile  process esegue (prima dell'esecuzione effettiva del codice) tutti gli identificatori dichiarati con var sarà inizializzato con undefinede quelli usati dal FunctionDeclaration's sarà disponibile da quel momento, ad esempio:

 alert(typeof foo); // 'function', it's already available
 alert(typeof bar); // 'undefined'
 function foo () {}
 var bar = function () {};
 alert(typeof bar); // 'function'

Il compito del bar  FunctionExpression ha luogo fino al runtime.

Una proprietà globale creata da a FunctionDeclaration può essere sovrascritto senza problemi, proprio come un valore variabile, ad es .:

 function test () {}
 test = null;

Un'altra ovvia differenza tra i due esempi è che la prima funzione non ha un nome, ma la seconda ha esso, che può essere davvero utile quando si esegue il debug (ad esempio, ispezionando uno stack di chiamate).

Informazioni sul primo esempio modificato ( foo = function() { alert('hello!'); };), è un incarico non dichiarato, ti incoraggio caldamente a usare sempre il var parola chiave.

Con un incarico, senza il var dichiarazione, se l'identificatore di riferimento non viene trovato nella catena dell'ambito, diventerà a cancellabili  proprietà dell'oggetto globale.

Inoltre, gli incarichi non dichiarati gettano a ReferenceError su ECMAScript 5 sotto Modalità rigorosa .

A deve leggere:

Nota : Questa risposta è stata unita da un'altra domanda , in cui il maggior dubbio e l'idea errata del PO erano quegli identificatori dichiarati con a FunctionDeclaration, non può essere sovrascritto, il che non è il caso.


133
2017-08-08 19:32



I due frammenti di codice che hai pubblicato in questa sezione, per quasi tutti gli scopi, si comportano allo stesso modo.

Tuttavia, la differenza di comportamento è che con la prima variante ( var functionOne = function() {}), quella funzione può essere chiamata solo dopo quel punto nel codice.

Con la seconda variante ( function functionTwo()), la funzione è disponibile per il codice che viene eseguito sopra dove viene dichiarata la funzione.

Questo perché con la prima variante, la funzione è assegnata alla variabile foo in fase di esecuzione. Nel secondo, la funzione è assegnata a quell'identificatore, foo, in fase di analisi.

Altre informazioni tecniche

JavaScript ha tre modi per definire le funzioni.

  1. Il tuo primo frammento mostra a espressione di funzione . Ciò comporta l'utilizzo del operatore "funzione"  per creare una funzione - il risultato di tale operatore può essere memorizzato in qualsiasi variabile o proprietà dell'oggetto. L'espressione della funzione è potente in questo modo. L'espressione di funzione è spesso chiamata "funzione anonima", perché non deve avere un nome,
  2. Il tuo secondo esempio è a dichiarazione di funzione . Questo usa il dichiarazione "funzione"  per creare una funzione. La funzione è resa disponibile in fase di analisi e può essere richiamata ovunque in tale ambito. Puoi ancora memorizzarlo in una proprietà variabile o oggetto in seguito.
  3. Il terzo modo di definire una funzione è il Costruttore "Function ()" , che non è mostrato nel tuo post originale. Si sconsiglia di usarlo poiché funziona allo stesso modo di eval(), che ha i suoi problemi.

111
2018-04-20 04:54



Una spiegazione migliore a La risposta di Greg

functionTwo();
function functionTwo() {
}

Perché nessun errore? Ci è sempre stato insegnato che le espressioni sono eseguite dall'alto verso il basso (??)

Perché:

Le dichiarazioni delle funzioni e le dichiarazioni delle variabili vengono sempre spostate ( hoisted) invisibilmente all'inizio del loro ambito di contenimento dall'interprete JavaScript. Parametri di funzione e nomi definiti dalla lingua sono, ovviamente, già lì. ben ciliegio

Ciò significa che il codice come questo:

functionOne();                  ---------------      var functionOne;
                                | is actually |      functionOne();
var functionOne = function(){   | interpreted |-->
};                              |    like     |      functionOne = function(){
                                ---------------      };

Si noti che la parte di assegnazione delle dichiarazioni non è stata sollevata. Solo il nome è issato.

Ma nel caso delle dichiarazioni di funzioni, anche l'intero corpo della funzione verrà issato :

functionTwo();              ---------------      function functionTwo() {
                            | is actually |      };
function functionTwo() {    | interpreted |-->
}                           |    like     |      functionTwo();
                            ---------------

91
2017-08-09 02:45



Altri commentatori hanno già coperto la differenza semantica delle due varianti sopra. Volevo notare una differenza stilistica: solo la variazione "assegnazione" può impostare una proprietà di un altro oggetto.

Io spesso costruisco moduli JavaScript con uno schema come questo:

(function(){
    var exports = {};

    function privateUtil() {
            ...
    }

    exports.publicUtil = function() {
            ...
    };

    return exports;
})();

Con questo modello, le tue funzioni pubbliche useranno tutte le assegnazioni, mentre le tue funzioni private usano la dichiarazione.

(Nota anche che l'assegnazione dovrebbe richiedere un punto e virgola dopo l'istruzione, mentre la dichiarazione lo proibisce).


83
2018-03-03 19:19



Un'illustrazione di quando preferire il primo metodo al secondo è quando è necessario evitare di ignorare le definizioni precedenti di una funzione.

Con

if (condition){
    function myfunction(){
        // Some code
    }
}

, questa definizione di myfunction sovrascriverà qualsiasi definizione precedente, poiché verrà eseguita in fase di analisi.

Mentre

if (condition){
    var myfunction = function (){
        // Some code
    }
}

fa il lavoro corretto di definire myfunction solo quando condition è incontrato.


68
2018-03-29 13:26



Un motivo importante è aggiungere una sola variabile come "Root" del tuo spazio dei nomi ...

var MyNamespace = {}
MyNamespace.foo= function() {

}

o

var MyNamespace = {
  foo: function() {
  },
  ...
}

Esistono molte tecniche per il namespace. È diventato più importante con la pletora di moduli JavaScript disponibili.

Vedi anche Come posso dichiarare un namespace in JavaScript?


55
2017-08-08 19:44



sollevamento   è l'azione dell'interprete JavaScript che sposta tutte le dichiarazioni di variabili e funzioni all'inizio dell'ambito corrente.  

Tuttavia, vengono issate solo le dichiarazioni effettive. lasciando i compiti dove sono.

  • le variabili / funzioni dichiarate all'interno della pagina sono globali e possono accedere ovunque in quella pagina.
  • le variabili / funzioni dichiarate all'interno della funzione hanno scope locale. significa che sono disponibili / accessibili all'interno del corpo della funzione (scope), non sono disponibili al di fuori del corpo della funzione.

Variabile

Javascript è chiamato linguaggio vagamente dattiloscritto. Il che significa che le variabili Javascript possono avere valore di qualsiasi Tipo di dati . Javascript si occupa automaticamente della modifica del tipo di variabile in base al valore / valore letterale fornito durante il runtime.

global_Page = 10;                                               var global_Page;      « undefined
    « Integer literal, Number Type.   -------------------       global_Page = 10;     « Number         
global_Page = 'Yash';                 |   Interpreted   |       global_Page = 'Yash'; « String
    « String literal, String Type.    «       AS        «       global_Page = true;   « Boolean 
var global_Page = true;               |                 |       global_Page = function (){          « function
    « Boolean Type                    -------------------                 var local_functionblock;  « undefined
global_Page = function (){                                                local_functionblock = 777;« Number
    var local_functionblock = 777;                              };  
    // Assigning function as a data.
};  

Funzione

function Identifier_opt ( FormalParameterList_opt ) { 
      FunctionBody | sequence of statements

      « return;  Default undefined
      « return 'some data';
}
  • le funzioni dichiarate all'interno della pagina sono issate in cima alla pagina con accesso globale.
  • le funzioni dichiarate all'interno del blocco funzione vengono issate in cima al blocco.
  • Il valore di ritorno predefinito della funzione è ' non definito ', Variabile  dichiarazione valore predefinito anche 'indefinito'

    Scope with respect to function-block global. 
    Scope with respect to page undefined | not available.
    

Dichiarazione delle funzioni

function globalAccess() {                                  function globalAccess() {      
}                                  -------------------     }
globalAccess();                    |                 |     function globalAccess() { « Re-Defined / overridden.
localAccess();                     «   Hoisted  As   «         function localAccess() {
function globalAccess() {          |                 |         }
     localAccess();                -------------------         localAccess(); « function accessed with in globalAccess() only.
     function localAccess() {                              }
     }                                                     globalAccess();
}                                                          localAccess(); « ReferenceError as the function is not defined

Espressione di funzione

        10;                 « literal
       (10);                « Expression                (10).toString() -> '10'
var a;                      
    a = 10;                 « Expression var              a.toString()  -> '10'
(function invoke() {        « Expression Function
 console.log('Self Invoking');                      (function () {
});                                                               }) () -> 'Self Invoking'

var f; 
    f = function (){        « Expression var Function
    console.log('var Function');                                   f ()  -> 'var Function'
    };

Funzione assegnata alla variabile Esempio:

(function selfExecuting(){
    console.log('IIFE - Immediately-Invoked Function Expression');
}());

var anonymous = function (){
    console.log('anonymous function Expression');
};

var namedExpression = function for_InternalUSE(fact){
    if(fact === 1){
        return 1;
    }

    var localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    //return; //undefined.
    return fact * for_InternalUSE( fact - 1);   
};

namedExpression();
globalExpression();

javascript interpretato come

var anonymous;
var namedExpression;
var globalExpression;

anonymous = function (){
    console.log('anonymous function Expression');
};

namedExpression = function for_InternalUSE(fact){
    var localExpression;

    if(fact === 1){
        return 1;
    }
    localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    return fact * for_InternalUSE( fact - 1);    // DEFAULT UNDEFINED.
};

namedExpression(10);
globalExpression();

È possibile controllare la dichiarazione delle funzioni, test di espressione su diversi browser utilizzando jsperf Test Runner


Classi di funzioni del costruttore ES5 : Oggetti funzione creati utilizzando Function.prototype.bind

JavaScript considera le funzioni come oggetti di prima classe, quindi essendo un oggetto, è possibile assegnare proprietà a una funzione.

function Shape(id) { // Function Declaration
    this.id = id;
};
    // Adding a prototyped method to a function.
    Shape.prototype.getID = function () {
        return this.id;
    };
    Shape.prototype.setID = function ( id ) {
        this.id = id;
    };

var expFn = Shape; // Function Expression

var funObj = new Shape( ); // Function Object
funObj.hasOwnProperty('prototype'); // false
funObj.setID( 10 );
console.log( funObj.getID() ); // 10

Introdotto ES6 Funzione freccia : Un'espressione di funzione di freccia ha una sintassi più breve, sono più adatti per le funzioni non di metodo e non possono essere utilizzate come costruttori.

ArrowFunction : ArrowParameters => ConciseBody.

const fn = (item) => { return item & 1 ? 'Odd' : 'Even'; };
console.log( fn(2) ); // Even
console.log( fn(3) ); // Odd

47
2018-01-25 14:46