Einfache JavaScript-Funktion mit sofortigem Aufruf funktioniert nicht ... warum?

Question

Kann jemand erklären, warum dies funktioniert:

var sayHello = function (name) { 
    alert("Hello there " + name + "!"); 
}("Mike"); 

Während dies nicht:

function sayHello (name) { 
    alert("Hello there " + name + "!"); 
}("Mike"); 

Mike Peat

Answer 1

Herausgegeben weil meine Antwort falsch die Original-Beitrag gelesen hatte:

Wie Ihre Funktion wird nicht mehr als Lambda-Funktion einem Wert zugewiesen, das Aufrufen der Funktion danach mit ("Mike") funktioniert nicht a Es gibt keinen Wert, den Aufruf aufzurufen. Wie andere vorgeschlagen diese mit Klammern Einwickeln einer temporären Variablen erstellen werden Sie noch die anonyme Funktion aufrufen lassen: eigentlich

(function sayHello (name) { 
    alert("Hello there " + name + "!"); 
})('Mike'); 

Answer 2

Ihre zweite Code:

function sayHello (name) { 
    alert("Hello there " + name + "!"); 
} 

("Mike"); 

So sind Sie zum ersten Mal erklärt Funktion „sayHello“ und dann führen Sie die "Anweisung" aus:

was nichts tut.

Answer 3

Dies funktioniert:

(function sayHello (name) { 
     alert("Hello there " + name + "!"); 
    })("Mike"); 

Beachten Sie die Pars selbst die Funktion wickeln. Sie können auch den Funktionsnamen "sayHello" entfernen und es funktioniert weiterhin. Soweit warum? Ich bin nicht positiv. Vielleicht ist es das, indem Sie es einer Variablen zuweisen und nicht die wrapping() 's verwenden, Sie ordnen es tatsächlich sayHello zu und führen dann hallo, nicht die anonyme Funktion aus.

Answer 4

die Funktionsdefinition in () Umgebung, bevor es Aufruf funktioniert:

(function sayHello(name) { 
    alert("Hello there " + name + "!"); 
})("Mike"); 

// however -- 
alert(typeof sayHello); // undefined 

So etwas wie, dass, wenn Sie wollen - man könnte genauso gut machen es nur eine anonyme Funktion:

(function(name) { 
    alert("Hello there " + name + "!"); 
})("Mike"); 

Und ich bin mir nicht sicher, dass es erforderlich ist - aber aus Sicherheitsgründen - immer wenn ich einen Verschluss verwende, wickle ich ihn immer in ()

Answer 5

var sayHello = function (name) { 
    alert("Hello there " + name + "!"); 
}("Mike"); 

Dies erstellt eine anonyme Funktion und ruft sie sofort mit dem Parameter "Mike" auf. Dann wird der Rückgabewert dieses Funktionsaufrufs der Variablen sayHello zugewiesen.

function sayHello (name) { 
    alert("Hello there " + name + "!"); 
}("Mike"); 

Dies definiert nur eine normale Funktion mit dem Namen sayHello und die Funktion Anweisung endet nach dem Schließen}. Dann folgt die ("Mike") Aussage, die gültig ist, aber nichts tut.

Answer 6

Alles, was Sie hier verstehen müssen, ist der Unterschied zwischen FunctionExpression s und FunctionDeclaration s in Javascript.

Wenn Sie Surround-Funktion mit Klammern -

(function sayHello (name) { 
    alert("Hello there " + name + "!"); 
})("Mike"); 

- Sie gelten technisch, eine Gruppierung Betreiber zu. Einmal angewendet, ist die Gesamtproduktion nicht mehr ein FunctionDeclarataion, sondern ein FunctionExpression. Vergleichen -

function foo(){ } // FunctionDeclaration 

(function foo(){ }); // FunctionExpresson 
typeof function(){ }; // FunctionExpression 
new function(){ }; // FunctionExpression 

FunctionExpression (im Gegensatz zu FunctionDeclaration), genau wie jedem anderen MemberExpresson mit Argumenten angehängt werden ("(" und ")") und wird in Funktionsaufruf führen. Genau deshalb wird die Funktion in Ihrem ersten Beispiel aufgerufen und nicht in einer Sekunde.

Beachten Sie, dass FunctionExpression s sind erlaubt haben, optional Identifier s (im Gegensatz zu FunctionDeclaration s, die immer eine haben muss), so dass Sie leicht „sayHello“ weglassen und mit so genannten anonymen Funktion am Ende Ausdruck -

(function(){ 
    alert('...'); 
}); 

Sie können my article on named function expressions überprüfen, die zwischen Funktionsausdrücken und Funktionsdeklarationen in viel mehr Details in subtilen Details der Unterschied eintaucht.