Perché dichiarare sempre le funzioni in JavaScript?

Question

Mi è stato detto che devi sempre dichiarare le funzioni in JavaScript. È vero? Qual è il vantaggio di questo?

solito assegnare funzioni ad una variabile come ad esempio:

var foo = function() {}; 

Ma si suppone che questo è sbagliato, qualcosa a che fare stack di tracciamento. Qualcuno può spiegare per favore? Mi è stato detto di fare:

var foo = function fooBar() {}; 

avrebbe senso se è assegnato a un oggetto?

Ricordate che queste funzioni non sono all'interno dell'ambito globale né eseguite autonomamente né utilizzate più volte.

Answer 1

Prima di tutto, una piccola nota sulla terminologia: ciò che si ha non è una dichiarazione di funzione. Questa è una dichiarazione di funzione:

function fooBar() { 
} 

Si crea una funzione denominata fooBar accessibili tramite la variabile fooBar. Questo è un compito che coinvolge un'espressione di funzione denominata: nome

var foo = function fooBar() { 
}; 

della funzione è ancora fooBar, ma la funzione è destinata esclusivamente a una variabile fooBar all'interno della funzione stessa e non al di fuori. Il fatto che esso rende la funzione accessibile all'interno del suo campo di applicazione senza dover fare riferimento a una variabile in un ambito esterno, però, significa che ci sono due motivi per citarne esso:

• Per la capacità di riferirsi al funzione dentro se stessa indipendentemente dal codice nella funzione esterna!

  Questo può tornare qualunque sia la funzione esterna vuole:

  function fooBar() { 
      return fooBar.toString(); 
  } 
  
  var baz = fooBar; 
  fooBar = 5; 
  baz(); // "5" 
  

  Questo è sempre coerente:

  var fooBar = function fooBar() { 
      return fooBar.toString(); 
  }; 
  
  var baz = fooBar; 
  fooBar = 5; 
  baz(); // "function fooBar() { …" 
  

• E sì, per una più dettagliata analisi dello stack:

  function trace(func) { 
      try { 
       func(); 
      } catch (error) { 
       console.log(error.stack); 
      } 
  } 
  
  trace(function() { 
      throw new Error("Bad thing"); 
  }); 
  /* 
  Error: Bad thing 
      at /home/ryan/test.js:10:18 
      at trace (/home/ryan/test.js:3:16) 
      at Object.<anonymous> (/home/ryan/test.js:9:8) 
      at Module._compile (module.js:410:26) 
      at Object.Module._extensions..js (module.js:428:10) 
      at Module.load (module.js:335:32) 
      at Function.Module._load (module.js:290:12) 
      at Function.Module.runMain (module.js:451:10) 
      at startup (node.js:123:18) 
      at node.js:866:3 
  */ 
  
  trace(function descriptiveName() { 
      throw new Error("Bad thing"); 
  }); 
  /* 
  Error: Bad thing 
      at descriptiveName (/home/ryan/test.js:14:18) 
      at trace (/home/ryan/test.js:3:16) 
      at Object.<anonymous> (/home/ryan/test.js:13:8) 
      at Module._compile (module.js:410:26) 
      at Object.Module._extensions..js (module.js:428:10) 
      at Module.load (module.js:335:32) 
      at Function.Module._load (module.js:290:12) 
      at Function.Module.runMain (module.js:451:10) 
      at startup (node.js:123:18) 
      at node.js:866:3 
  */ 
  

  (Node.js nella foto qui.) Nota lo descriptiveName nella parte superiore della seconda traccia dello stack . Ciò è particolarmente utile quando si hanno sistemi un po 'complicati di callback asincroni, eventi, metodi su oggetti che vengono passati in giro e così via.