Perché la chiusura è importante per JavaScript?

Perché javascript non ha funzionalità come gli spazi dei nomi, e puoi rovinare abbastanza facilmente con tutti i tipi di oggetti globali.

Quindi è importante essere in grado di isolare del codice nel proprio ambiente di esecuzione. La chiusura è perfetta per questo.

Questo uso della chiusura non ha senso in un linguaggio come C # in cui hai spazi dei nomi, classi e così via per isolare il codice e non mettere tutto nello scope globale.

Una pratica molto comune per il codice javascript sta scrivendo in questo modo:

(function(){
    // Some code
})();

Come puoi vedere, questa è una dichiarazione di funzione anonima, seguita immediatamente dalla sua esecuzione. Quindi, tutto ciò che è definito all'interno della funzione è impossibile da accedere dall'esterno, e non rovinerai l'ambito globale. Il contesto di esecuzione di questa funzione rimarrà attivo fintanto che alcuni codici lo utilizzano, come le funzioni annidate definite in questo contesto, che puoi passare come callback o altro.

Javascript è una lingua molto diversa da C #. Non è orientato agli oggetti, è orientato al prototipo. Ciò porta a pratiche molto diverse alla fine.

In ogni caso, le chiusure sono buone, quindi usali anche in C #!

EDIT: dopo alcuni discorsi sulla chat di StackOverflow, penso che questa anwer debba essere precentrata.

La funzione nel codice di esempio non è una chiusura. Tuttavia, questa funzione può definire variabili locali e funzioni annidate. Tutte le funzioni annidate che utilizzano queste variabili locali sono chiusure.

Questo è utile per condividere alcuni dati attraverso una serie di funzioni senza rovinare l'ambito globale. Questo è l'uso più comune della chiusura in javascript.

La chiusura è molto più efficace della semplice condivisione di alcuni dati come questo, ma siamo realisti, la maggior parte dei programmatori non sa nulla della programmazione funzionale. In C # avresti usato la classe o uno spazio dei nomi per questo tipo di utilizzo, ma JS non fornisce questa funzionalità.

Puoi fare molto di più con la chiusura che proteggere l'ambito globale, ma questo è ciò che vedrai nel codice sorgente di JS.

Probabilmente perché le implementazioni popolari dell'orientamento agli oggetti di JavaScript dipendono dalle chiusure. Diamo un'occhiata ad un semplice esempio:

function counter() {
   var value = 0;
   this.getValue = function() { return value; }
   this.increase = function() { value++; }
}

var myCounter = new counter();
console.log(myCounter.getValue());
myCounter.increase();
console.log(myCounter.getValue());

I metodi getValue e increase sono di fatto chiusure, incapsulando la variabile value .

Poiché molte delle librerie che rendono "bearable" JavaScript lo utilizzano.

Dai un'occhiata a JQuery , Prototype o MooTools , solo per citarne tre popolari. Ciascuna di queste librerie fornisce un metodo each per le proprie raccolte come metodo di iterazione preferito, che utilizza una funzione iteratore. Quella funzione, quando si accede ai valori nello scope esterno, sarà una chiusura:

[1,2,3].each(function(item) {
   console.log(item);
});

E non si ferma qui: i callback in Ajax, la gestione degli eventi in Ext.js, ecc. assumono tutte le funzioni e, se non vuoi gonfiare il tuo codice con 100eds di funzioni chiamate esattamente una volta, le chiusure sono la via per andare.

Sono d'accordo con le altre risposte che la codifica "buona" con JavaScript dipende in misura maggiore dalle chiusure. Tuttavia, in aggiunta a ciò, è probabilmente solo una questione di quanto a lungo è stata utilizzata la funzione in ciascuna lingua. JavaScript ha praticamente avuto chiusure sin dalle sue prime implementazioni. C # d'altra parte ha avuto solo dal 3.0, che è stato rilasciato con Visual Studio 2008.

Molti programmatori C # in cui mi imbatto continuano a lavorare su progetti 2.0. E anche se lavorano in 3.0 o 4.0, spesso usano ancora gli idiomi 2.0. Amo le chiusure; si spera che diventeranno più pesantemente utilizzati in C # come il concetto si propaga tra gli sviluppatori di C #.

Il motivo principale è perché C # è tipizzato in modo statico e le funzioni hanno solo accesso a un singolo ambiente predeterminato, che impedisce l'utilità delle chiusure.

In JavaScript, d'altra parte, le chiusure consentono alle funzioni di comportarsi come metodi quando si accede come una proprietà dell'oggetto e sono oggetti di prima classe, possono anche essere iniettati in ambienti diversi che consentono alle subroutine di operare in diversi contesti.

Una delle ragioni per cui ho dovuto apprendere su di loro è che quando esegui il looping degli elementi DOM (o di qualsiasi cosa), vuoi essere in grado di "chiudere" o "incapsulare" l'ambito della variabile. Come nell'esempio pubblicato qui: link