Heute habe ich die selbstausführenden Funktionen gekreuzt, als ich es irgendwie wusste Selbstausführende anonyme Funktionen , dann habe ich diesen Artikel gelesen: http://briancrescimanno.com/how-self-executing-anonymous-functions-work/

Die Sache ist, dass ich nicht weiß, WARUM selbstausführende anonyme Funktionen verwenden soll, denn wenn ich etwas tun muss wie:

var test = "a";
(function(foo) {
    alert(foo);
})(test);

Ich könnte einfach so etwas machen wie:

var test = "a";
alert(foo);

Oder habe ich etwas vermisst?

Dies kann auch mit jedem Code innerhalb der Funktion durchgeführt werden, aber ich habe alert () verwendet, um es einfach zu machen


Aktualisieren:

Obwohl ich bereits akzeptiert und geantwortet habe, möchte ich etwas mitteilen, das ich gefunden habe, falls jemand später auf diese Frage stößt :)

Mit dieser Notation können wir auch eine Endlosschleife wie folgt erstellen:

(function loop(){
    // do something here
    loop();
)();
1
Abu Romaïssae 22 Nov. 2013 im 14:09

4 Antworten

Beste Antwort

Ihr erstes Beispiel ist es nicht wert, in einer anonymen Funktion ausgeführt zu werden. Daher ist es ein schlechtes Beispiel, um zu verstehen, WARUM diese Technik verwendet werden soll. Hier ist ein gutes Beispiel, um die Erfassung von Zuständen zu untersuchen:

var list = [{id: 1, data: null}, ...];

for (var i = 0; i < list.length; i++) {
  (function(item) {
    // start async request, for each item in the list, in the order of the list
    asyncAjax("get-data-from-somewhere.json?what=" + list[i].id, function (response) {
      // thats the on success callback, which gets executed when the server responded
      // each item will have different response times, therefore the order of response is various
      // if we would use simply list[i].data, it wouldn't work correctly, because "i" would has the value of list.length, because the iteration has been finished yet.
      item.data = response;
    });
  })(list[i]);   // the function will preserve the reference to the list item inside, until the function has been fully executed
}

Beim Schreiben von Sync. Code können Sie jederzeit auf den klassischen objektorientierten Stil der Strukturierung Ihres Codes zurückgreifen. So können Sie Schließungen / sofort anonyme Funktionsaufrufe vermeiden. Aber sobald Sie Async verwenden. Mechanik, Verschlüsse werden sehr praktisch und lassen Ihren Code sauberer aussehen, natürlich nur, wenn Sie Verschlüsse lesen und verstehen können :)

Übrigens könnte man auch einfach schreiben:

function(private) {}(outer)

Ist das gleiche wie

(function(private) {})(outer)

Aber das zweite ist besser, weil es für den Leser einfach offensichtlicher ist.

2
Markus Siebeneicher 18 Apr. 2014 im 11:56

Es gibt mehrere Gründe, warum man ein IIFE verwenden würde:

1) Keine Abfälle

var a = 'foo';
alert(a);

Vs

(function() {
  var a = 'foo';
  alert(a);
}())

Beide Beispiele machen dasselbe, aber im zweiten Beispiel gibt es keine Variable innerhalb des äußeren Bereichs.

2) Zustandserfassung

var a = 'foo';
window.setTimeout(function() { alert(a); }, 1);
a = 'bar';

Vs

var a = 'foo';
window.setTimeout( (function(a_copy) { 
    return function() { alert(a_copy); }
  }(a)), 1);
a = 'bar';

Das erste Beispiel warnt bar, während das zweite foo warnt. Sie finden diese Technik besonders bei Loops.

4
Tibos 22 Nov. 2013 im 10:17

Die von Ihnen beschriebene Syntax wird üblicherweise als "sofort aufgerufener Funktionsausdruck" oder IIFE bezeichnet.

Einer der häufigsten Anwendungsfälle ist die Emulation privater Variablen:

var ns = (function () {
    var x = 1; // "private"
    return {
        getX: function () {
            return x;
        }
    }
}());
ns.getX(); // 1
ns.x; // undefined because x is "private"

In diesem Beispiel ist die Variable x lokal für das IIFE. Es ist nicht direkt außerhalb zugänglich. Da jedoch auf die Methode getX verwiesen wird, auf die außerhalb des IIFE zugegriffen werden kann (da sie Teil des zurückgegebenen Objekts ist), wird ein Verweis auf x am Leben erhalten . Dies ist, was normalerweise mit dem Begriff "Schließung" gemeint ist.

2
James Allardice 22 Nov. 2013 im 10:14

Selbstausführende Funktionen sind nicht wirklich nützlich, wenn Sie nur ein alert im Inneren ausführen.

Betrachten Sie so etwas:

(function(foo) {
    var a = ..
    // do something with a and foo
})(test);

Der Vorteil hierbei ist, dass a innerhalb der Methode "privat" ist und nicht außerhalb der Methode verwendet werden kann. a endet also nicht als globale Variable und kann nicht von einem anderen Javascript überschrieben werden, das eine gleichnamige Variable verwendet.

1
micha 22 Nov. 2013 im 10:14