function-Ausdruck
Baseline
Weitgehend verfügbar
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Mit dem Schlüsselwort function können Sie eine Funktion innerhalb eines Ausdrucks definieren.
Sie können Funktionen auch mit einer function-Deklaration oder der Pfeilsyntax definieren.
Probieren Sie es aus
const getRectArea = function (width, height) {
return width * height;
};
console.log(getRectArea(3, 4));
// Expected output: 12
Syntax
function (param0) {
statements
}
function (param0, param1) {
statements
}
function (param0, param1, /* …, */ paramN) {
statements
}
function name(param0) {
statements
}
function name(param0, param1) {
statements
}
function name(param0, param1, /* …, */ paramN) {
statements
}
Hinweis:
Eine Ausdrucksanweisung darf nicht mit dem Schlüsselwort function beginnen, um eine Verwechslung mit einer function-Deklaration zu vermeiden. Das Schlüsselwort function beginnt nur dann einen Ausdruck, wenn es in einem Kontext steht, der keine Anweisungen zulässt.
Parameter
nameOptional-
Der Funktionsname. Er kann weggelassen werden; in diesem Fall ist die Funktion anonym. Der Name ist nur innerhalb des Funktionskörpers sichtbar.
paramNOptional-
Der Name eines formalen Parameters der Funktion. Informationen zur Parametersyntax finden Sie in der Funktionsreferenz.
statementsOptional-
Die Anweisungen, aus denen der Funktionskörper besteht.
Beschreibung
Ein function-Ausdruck ist einer function-Deklaration sehr ähnlich und hat nahezu dieselbe Syntax. Der wichtigste Unterschied zwischen einem function-Ausdruck und einer function-Deklaration ist der Funktionsname: Bei function-Ausdrücken kann er weggelassen werden, um anonyme Funktionen zu erstellen. Ein function-Ausdruck kann als IIFE (Immediately Invoked Function Expression) verwendet werden, die unmittelbar nach ihrer Definition ausgeführt wird. Weitere Informationen finden Sie im Kapitel über Funktionen.
Hoisting von function-Ausdrücken
Anders als Funktionsdeklarationen werden Funktionsausdrücke in JavaScript nicht durch Hoisting vorgezogen. Sie können Funktionsausdrücke nicht verwenden, bevor Sie sie erstellt haben:
console.log(notHoisted); // undefined
// Even though the variable name is hoisted,
// the definition isn't. so it's undefined.
notHoisted(); // TypeError: notHoisted is not a function
var notHoisted = function () {
console.log("bar");
};
Benannter function-Ausdruck
Wenn Sie innerhalb des Funktionskörpers auf die aktuelle Funktion verweisen möchten, müssen Sie einen benannten Funktionsausdruck erstellen. Dieser Name ist dann nur innerhalb des Funktionskörpers sichtbar (Scope). So müssen Sie nicht die veraltete Eigenschaft arguments.callee verwenden, um die Funktion rekursiv aufzurufen.
const math = {
factorial: function factorial(n) {
console.log(n);
if (n <= 1) {
return 1;
}
return n * factorial(n - 1);
},
};
math.factorial(3); // 3;2;1;
Wenn ein Funktionsausdruck benannt ist, wird die Eigenschaft name der Funktion auf diesen Namen gesetzt, statt auf den impliziten Namen, der aus der Syntax abgeleitet wird (etwa aus der Variablen, der die Funktion zugewiesen wird).
Anders als bei Deklarationen ist der Name eines Funktionsausdrucks schreibgeschützt.
"use strict";
function foo() {
foo = 1;
}
foo();
console.log(foo); // 1
(function foo() {
foo = 1; // TypeError: Assignment to constant variable.
})();
Beispiele
>Einen function-Ausdruck verwenden
Das folgende Beispiel definiert eine unbenannte Funktion und weist sie x zu. Die Funktion gibt das Quadrat ihres Arguments zurück:
const x = function (y) {
return y * y;
};
Eine Funktion als Callback verwenden
Häufiger wird ein Funktionsausdruck als Callback verwendet:
button.addEventListener("click", function (event) {
console.log("button is clicked!");
});
Einen unmittelbar aufgerufenen Funktionsausdruck (IIFE) verwenden
IIFEs sind ein verbreitetes Muster, um beliebig viele Anweisungen in ihrem eigenen Scope auszuführen (und gegebenenfalls einen Wert zurückzugeben), wo nur ein einzelner Ausdruck zulässig ist. Viele herkömmliche Anwendungsfälle für IIFEs sind durch neue Syntaxfunktionen wie Module und Deklarationen mit Block-Scope überflüssig geworden. IIFEs selbst werden heute häufiger mit Pfeilfunktionen geschrieben, das Grundprinzip bleibt jedoch gleich. Im Allgemeinen sehen IIFEs so aus:
// standard IIFE
(function () {
// statements…
})();
// IIFE with arguments
(function (a, b) {
console.log(a + b);
})(1, 2); // logs 3
// IIFE being used to initialize a variable
const value = (() => {
const randomValue = Math.random();
if (randomValue > 0.5) {
return "heads";
}
return "tails";
})();
Im Folgenden werden mehrere Anwendungsfälle anhand von Beispielen vorgestellt.
Den globalen Namensraum in Skriptcode nicht überladen
Alle Skripte teilen sich den Scope auf oberster Ebene. Dieser kann viele Funktionen und globale Variablen aus verschiedenen Dateien enthalten. Um Namenskonflikte zu vermeiden, ist es daher wichtig, die Anzahl global deklarierter Namen zu begrenzen (in Modulen ist dieses Problem deutlich geringer; dennoch kann es nützlich sein, den Scope temporärer Variablen zu begrenzen, insbesondere bei sehr langen Dateien). Wenn wir Initialisierungscode haben, den wir nicht erneut benötigen, können wir das IIFE-Muster verwenden. Das ist besser als eine Funktionsdeklaration oder ein Funktionsausdruck, weil es sicherstellt, dass der Code nur an dieser Stelle und nur einmal ausgeführt wird.
// top-level of a script (not a module)
var globalVariable = (() => {
// some initialization code
let firstVariable = something();
let secondVariable = somethingElse();
return firstVariable + secondVariable;
})();
// firstVariable and secondVariable cannot be accessed outside of the function body.
Das Modulmuster
Mit IIFEs können wir auch private und öffentliche Variablen und Methoden erstellen. Eine ausführlichere Behandlung des Modulmusters und weiterer Anwendungen von IIFEs finden Sie im Buch „Learning JavaScript Design Patterns“ von Addy Osmani.
const makeWithdraw = (balance) =>
((copyBalance) => {
let balance = copyBalance; // This variable is private
const doBadThings = () => {
console.log("I will do bad things with your money");
};
doBadThings();
return {
withdraw(amount) {
if (balance >= amount) {
balance -= amount;
return balance;
}
return "Insufficient money";
},
};
})(balance);
const firstAccount = makeWithdraw(100); // "I will do bad things with your money"
console.log(firstAccount.balance); // undefined
console.log(firstAccount.withdraw(20)); // 80
console.log(firstAccount.withdraw(30)); // 50
console.log(firstAccount.doBadThings); // undefined; this method is private
const secondAccount = makeWithdraw(20); // "I will do bad things with your money"
console.log(secondAccount.withdraw(30)); // "Insufficient money"
console.log(secondAccount.withdraw(20)); // 0
for-Schleife mit var vor ES6
In älterem Code, der vor der Einführung der Deklarationen let und const mit Block-Scope geschrieben wurde, kann das IIFE-Muster wie folgt verwendet werden. Bei var gibt es nur Funktions-Scopes und den globalen Scope.
Angenommen, wir möchten zwei Schaltflächen mit den Beschriftungen „Button 0“ und „Button 1“ erstellen. Beim Anklicken sollen sie 0 beziehungsweise 1 protokollieren. Der folgende Code funktioniert nicht:
for (var i = 0; i < 2; i++) {
const button = document.createElement("button");
button.innerText = `Button ${i}`;
button.onclick = function () {
console.log(i);
};
document.body.appendChild(button);
}
console.log(i); // 2
Beim Anklicken protokollieren beide Schaltflächen 2, weil i global ist und zuletzt den Wert 2 hat. Vor ES6 konnten wir dieses Problem mit dem IIFE-Muster beheben:
for (var i = 0; i < 2; i++) {
const button = document.createElement("button");
button.innerText = `Button ${i}`;
button.onclick = (function (copyOfI) {
return function () {
console.log(copyOfI);
};
})(i);
document.body.appendChild(button);
}
console.log(i); // 2
Beim Anklicken protokollieren die Schaltflächen „Button 0“ und „Button 1“ 0 beziehungsweise 1. Die Variable i ist global definiert. Mit let könnten wir stattdessen Folgendes tun:
for (let i = 0; i < 2; i++) {
const button = document.createElement("button");
button.innerText = `Button ${i}`;
button.onclick = function () {
console.log(i);
};
document.body.appendChild(button);
}
console.log(i); // Uncaught ReferenceError: i is not defined.
Beim Anklicken protokollieren diese Schaltflächen 0 beziehungsweise 1.
Kontrollflussanweisungen an Stellen für Ausdrücke
Mit IIFEs können wir Sprachkonstrukte wie switch innerhalb eines Ausdrucks verwenden.
someObject.property = (() => {
switch (someVariable) {
case 0:
return "zero";
case 1:
return "one";
default:
return "unknown";
}
})();
Dieser Ansatz kann besonders nützlich sein, wenn Sie eine Variable mit const deklarieren möchten, bei der Initialisierung aber sonst let oder var verwenden müssten:
let onlyAssignedOnce;
try {
onlyAssignedOnce = someFunctionThatMightThrow();
} catch (e) {
onlyAssignedOnce = null;
}
Mit einer IIFE können wir die Variable mit const deklarieren:
const onlyAssignedOnce = (() => {
try {
return someFunctionThatMightThrow();
} catch (e) {
return null;
}
})();
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-function-definitions> |