Erklären Sie die gekapselte anonyme Funktion syntax

Zusammenfassung

Können Sie erklären, die Logik hinter der syntax gekapselt anonyme Funktionen in JavaScript? Warum funktioniert das: (function(){})(); aber nicht: function(){}();?

, Was ich weiß,

In JavaScript erstellt man eine benannte Funktion wie diese:

function twoPlusTwo(){
    alert(2 + 2);
}
twoPlusTwo();

Können Sie auch eine anonyme Funktion und weisen Sie es einer Variablen:

var twoPlusTwo = function(){
    alert(2 + 2);
};
twoPlusTwo();

Können Sie Kapseln sich ein block von code, indem eine anonyme Funktion, dann wickeln Sie es in eckige Klammern und ihn sofort auszuführen:

(function(){
    alert(2 + 2);
})();

Dies ist nützlich bei der Erstellung von modularisierten Skripte, um zu vermeiden, überladen den aktuellen Bereich, oder den globalen scope, mit potenziell widersprüchlichen Variablen - wie im Fall von Greasemonkey scripts, jQuery plugins, etc.

Nun verstehe ich, warum das funktioniert. Die Klammern umschließen den Inhalt und setzen Sie nur das Ergebnis (ich bin sicher, es gibt eine bessere Weise, das zu beschreiben), wie mit (2 + 2) === 4.

Was ich nicht verstehe

Aber ich verstehe nicht, warum dies nicht funktioniert ebenso gut:

function(){
    alert(2 + 2);
}();

Können Sie erklären, dass Sie für mich?

Ich denke, all diese abwechslungsreiche notation und Möglichkeiten, definieren/Einstellung/Aufruf von Funktionen, die die meisten verwirrend Teil zunächst die Arbeit mit javascript. Menschen neigen dazu, nicht über Sie sprechen entweder. Es ist nicht eine betonte Stelle in Führungen oder blogs. Es weht meinem Kopf, weil es ist etwas verwirrend für die meisten Menschen, und Menschen fließend in js muss es zu Durchlaufen haben. Es ist wie das leeren Tabu Realität, die nie gesprochen wird.
Lesen Sie auch über die Zweck dieses Konstrukts, oder überprüfen Sie ein (technischer) Erläuterung (auch hier). Für die Platzierung der Klammern, siehe diese Frage über Ihre Lage.
OT: Für diejenigen, die wissen wollen, wo diese anonyme Funktionen werden oft benutzt, Lesen Sie bitte adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html
Das ist ein typischer Fall von Sofort Aufgerufen Funktion Ausdrücken (IIFE).

InformationsquelleAutor Premasagar | 2009-10-27

48

Obwohl dies ist eine alte Frage und Antwort, es behandelt ein Thema, das an diesem Tag wirft viele Entwickler für eine Schleife. Ich kann nicht zählen die Anzahl der JavaScript-Entwickler-Kandidaten, die ich interviewt habe, die konnte mir nicht sagen, der Unterschied zwischen einer Funktions-Deklaration und eine Funktion Ausdruck und, der hatte keine Ahnung, was ein sofort aufgerufen, die Funktion Ausdruck ist.

Erwähnen möchte ich, allerdings eine sehr wichtige Sache ist, dass Premasagar code-snippet, das würde nicht funktionieren, selbst wenn er es gegeben hatte, ein name-Bezeichner.
```
function someName() {
    alert(2 + 2);
}();
```
Dem Grund würde dies nicht funktionieren, ist, dass die JavaScript-engine interpretiert dies als eine Funktions-Deklaration, gefolgt von einer völlig anderen Gruppierung operator, enthält kein Ausdruck, und die Gruppierung der Operatoren muss einen Ausdruck enthalten. Nach JavaScript, das obige code-snippet ist äquivalent zu dem folgenden.
```
function someName() {
    alert(2 + 2);
}

();
```
Andere Sache, die ich möchte darauf hinweisen, dass Ihnen von nutzen sein kann für einige Menschen ist, dass jeder name Kennung, die Sie für die Funktion Ausdruck ist ziemlich nutzlos im Zusammenhang mit dem Kodex mit Ausnahme von innerhalb der definition der Funktion selbst.
```
var a = function b() {
    //do something
};
a(); //works
b(); //doesn't work

var c = function d() {
    window.setTimeout(d, 1000); //works
};
```
Natürlich mit Namen von Bezeichnern mit Ihrer Funktion Definitionen ist immer hilfreich, wenn es um das Debuggen von code, aber das ist etwas ganz anderes... 🙂

InformationsquelleAutor natlee75
8

In javascript, das heißt Sofort-Invoked Function Expression (IIFE) .

Damit es eine Funktion, Ausdruck haben Sie zu:
1. umschließen Sie es mit ()
2. Ort ein void-operator, bevor es
3. es einer Variablen zuweisen.
Sonst wird es behandelt wie die definition einer Funktion und dann werden Sie nicht in der Lage, call - /invoke es in der gleichen Zeit, indem Sie die folgende Weise:
```
 function (arg1) { console.log(arg1) }(); 
```
Oben geben Sie Fehler. Da kann man nur eine Funktion aufzurufen Ausdruck sofort.

Dies kann erreicht werden, paar Möglichkeiten:
Weg 1:
```
(function(arg1, arg2){
//some code
})(var1, var2);
```
Weg 2:
```
(function(arg1, arg2){
//some code
}(var1, var2));
```
Weg 3:
```
void function(arg1, arg2){
//some code
}(var1, var2);
```
Weg 4:
```
  var ll = function (arg1, arg2) {
      console.log(arg1, arg2);
  }(var1, var2);
```
Alle oben sofort aufrufen der Funktion Ausdruck.

InformationsquelleAutor asmmahmud
3

Habe ich nur eine weitere kleine Bemerkung. Dein code funktioniert mit kleiner änderung:
```
var x = function(){
    alert(2 + 2);
}();
```
Ich den oben genannten syntax anstelle des mehr verbreiteten version:
```
var module = (function(){
    alert(2 + 2);
})();
```
weil ich es nicht geschafft, den Einzug, um ordnungsgemäß für die javascript-Dateien in vim. Es scheint, dass vim nicht wie die geschweiften Klammern innen offene Klammer.

Warum also funktioniert diese syntax funktioniert, wenn Sie zuweisen, die ausgeführt Ergebnis der Variablen, aber nicht standalone?
Da der JavaScript-engine interpretiert jedes gültige JavaScript-Anweisung, beginnend mit der function keyword als Funktionsdeklaration in welchem Fall das nachfolgende () wird interpretiert als ein grouping operator, die nach JavaScript-syntax-Regeln, kann nur und muss enthalten einen JavaScript-Ausdruck.
Ihre bevorzugte syntax funktioniert gut, aber es ist eine gute Idee, verwenden Sie entweder die "weiter verbreitet-version", Sie verwiesen wird oder die Variante, wo () ist eingeschlossen innerhalb der Gruppierung der Betreiber (die von Douglas Crockford empfiehlt dringend) für die Konsistenz: es ist üblich, verwenden Sie IIFEs ohne Zuordnung zu einer Variablen, und es ist leicht zu vergessen, um auch diese Verpackung Klammern, wenn Sie nicht verwenden Sie konsequent.

InformationsquelleAutor Andrei Bozantan
0

Vielleicht die kürzere Antwort wäre, dass
```
function() { alert( 2 + 2 ); }
```
ist ein funktionsliteral, dass definiert eine (anonyme) Funktion. Eine zusätzliche ()-paar, das sich als Ausdruck interpretiert, ist nicht zu erwarten, auf oberster Ebene, nur Literale.
```
(function() { alert( 2 + 2 ); })();
```
ist in einem Ausdruck, dass ruft eine anonyme Funktion.

InformationsquelleAutor theking2
0
```
(function(){
     alert(2 + 2);
 })();
```
Oben ist gültige syntax, da alles bestanden innerhalb der Klammer betrachten Sie als Funktion Ausdruck.
```
function(){
    alert(2 + 2);
}();
```
Oben ist keine gültige syntax. Da java-script-syntax-parser sucht nach Funktion name nach dem Schlüsselwort function, da Sie nicht alles finden, es gibt eine Fehlermeldung.

Während Ihre Antwort ist nicht falsch, die akzeptierte Antwort deckt bereits alle im dept.

InformationsquelleAutor Vithy
0

Können Sie verwendet werden, mit Parameter-Argumente wie
```
var x = 3; 
var y = 4;

(function(a,b){alert(a + b)})(x,y)
```
führen würde als 7

InformationsquelleAutor Jude
0

Diese extra-Klammern schafft zusätzliche anonyme Funktionen zwischen den globalen namespace und anonymen Funktion, die den code enthält. Und in Javascript-Funktionen deklariert innerhalb anderer Funktionen können nur auf namespace der übergeordneten Funktion, die Sie enthält. Da gibt es extra Objekt (anonymious Funktion) zwischen Globale Reichweite und der eigentliche code scoping-ist nicht beibehalten.

InformationsquelleAutor Jarkko Hietala
0

Können Sie es auch verwenden, wie:
```
! function() { console.log('yeah') }()
```
oder
```
!! function() { console.log('yeah') }()
```
! - negation op wandelt die fn-definition fn-Ausdruck, daher können Sie es aufrufen, sofort mit (). Gleiche wie mit 0,fn def oder void fn def

InformationsquelleAutor Csaba K.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.