Funktionsaufrufausdruck
Die Syntax des Funktionsaufrufausdrucks wertet den Rumpf einer Funktion mit den angegebenen Argumenten aus und gibt das Ergebnis zurück.
Probieren Sie es aus
function getRectArea(width, height) {
return width * height;
}
console.log(getRectArea(3, 4));
// Expected output: 12
Syntax
fn()
fn(arg1)
fn(arg1, arg2)
fn(arg1, arg2, /* …, */ argN)
Parameter
fn-
Ein Ausdruck mit einer Priorität von mindestens 17 (Zugriff und Aufruf). Das Ergebnis muss eine aufrufbare Funktion sein. Üblicherweise handelt es sich um einen Bezeichner, einen Eigenschaftszugriff oder einen Funktionsausdruck (das IIFE-Muster).
arg1, …,argNOptional-
Jedes Argument kann ein Spread-Argument oder ein Ausdruck mit einer Priorität von mindestens 2 (Zuweisung) sein.
Rückgabewert
- Wenn die Funktion eine normale Funktion ist, wird ihr gesamter Rumpf ausgewertet. Der Aufrufausdruck ergibt ihren Rückgabewert oder
undefined, wenn das Ende des Funktionsrumpfs erreicht wird, ohne dass einereturn-Anweisung ausgeführt wurde. - Wenn die Funktion eine async function ist, wird ihr Rumpf bis zum ersten
await-Ausdruck oder bis zum Abschluss der Funktion ausgewertet. Der Aufrufausdruck ergibt eine noch ausstehendePromise, wenn einawaiterreicht wird, oder eine auf den Rückgabewert aufgelöste Promise, wenn die Funktion ohneawaitendet. - Wenn die Funktion eine Generatorfunktion ist, ergibt der Aufrufausdruck ein neues
Generator-Objekt. Die Ausführung des Funktionsrumpfs beginnt beim ersten Aufruf dernext()-Methode des Generators. - Wenn die Funktion eine asynchrone Generatorfunktion ist, ergibt der Aufrufausdruck ein neues
AsyncGenerator-Objekt. Die Ausführung des Funktionsrumpfs beginnt beim ersten Aufruf dernext()-Methode des Generators. Diese gibt eine Promise für das nächste Iteratorergebnis zurück.
Ausnahmen
TypeError-
Wird ausgelöst, wenn
fnnicht aufrufbar ist. Dazu gehören Fälle, in denenfnkeine Funktion ist (typeof fn !== "function"), eine Klasse ist oder beim Aufruf immer einen Fehler auslöst (wieMap(), das stattdessen mitnewkonstruiert werden muss).
Der Aufrufausdruck gibt außerdem nicht abgefangene Fehler weiter, die bei der Auswertung des Funktionsrumpfs auftreten:
- Bei einer normalen Funktion werden nicht abgefangene Fehler aus dem Funktionsrumpf zu Fehlern des Aufrufausdrucks.
- Bei einer async function führen nicht abgefangene Fehler dazu, dass die zurückgegebene Promise zurückgewiesen wird.
- Bei einer Generatorfunktion werden nicht abgefangene Fehler zu Fehlern der
next()-Methode. - Bei einer asynchronen Generatorfunktion führen nicht abgefangene Fehler dazu, dass die von der
next()-Methode zurückgegebene Promise zurückgewiesen wird.
Beschreibung
Bei der Auswertung eines Funktionsaufrufs wird zuerst der Ausdruck fn ausgewertet. Anschließend werden die Argumentausdrücke der Reihe nach ausgewertet, wobei Spread-Argumente an der jeweiligen Stelle entfaltet werden. Erst nachdem alle Ausdrücke ausgewertet wurden, wird geprüft, ob fn aufrufbar ist. Zum Beispiel:
1(console.log("Hi")); // Logs "Hi"
// Uncaught TypeError: 1 is not a function
Obwohl 1 nicht aufrufbar ist, tritt die Nebenwirkung des Arguments trotzdem ein.
Im Gegensatz dazu werden bei der optionalen Verkettung die Argumente nicht ausgewertet, wenn fn bereits null oder undefined ist.
null?.(console.log("Hi")); // Nothing logged
Die Argumentliste muss nicht mit den Parametern übereinstimmen, die die Funktion deklariert hat. Werden weniger Argumente übergeben, als die Funktion erwartet, erhalten die übrigen Parameter den Wert undefined. Werden mehr Argumente übergeben, werden diese trotzdem ausgewertet und sind innerhalb der Funktion über das arguments-Objekt zugänglich.
Argumente werden immer als Wert übergeben und niemals als Referenz übergeben. Das bedeutet: Wenn eine Funktion einem Parameter einen neuen Wert zuweist, ändert sich der Wert außerhalb der Funktion nicht. Genauer gesagt werden Objektargumente durch gemeinsame Nutzung übergeben. Werden Eigenschaften des Objekts verändert, wirkt sich das daher auch außerhalb der Funktion aus. Weitere Informationen finden Sie im Leitfaden zu Funktionen.
Der Aufrufausdruck stellt dem Funktionsrumpf den this-Kontext bereit. Dieser wird durch einen Eigenschaftszugriff festgelegt, der gegebenenfalls in Klammern steht. In [].push(1); ist beispielsweise [].push der aufgerufene Funktionswert, während [] der this-Wert ist.
Beispiele
>Eine normale Funktion aufrufen
Normale Funktionen geben JavaScript-Werte direkt zurück (auch undefined ist möglich).
function completes(a, b) {
console.log(a, b);
}
function returns(a, b) {
return a + b;
}
function throws(a, b) {
throw new Error(`${a} and ${b}`);
}
console.log(completes(1, 2)); // Logs 1 2; returns undefined
console.log(returns(3, 4)); // 7
console.log(throws(5, 6)); // Error: 5 and 6
Eine async function aufrufen
Async functions geben Promise-Objekte zurück.
async function awaits(a, b) {
console.log("awaits() starts");
await new Promise((resolve) => setTimeout(resolve, 10));
return a + b;
}
async function returns(a, b) {
console.log("returns() starts");
return a + b;
}
async function throws(a, b) {
console.log("throws() starts");
throw new Error(`${a} and ${b}`);
}
awaits(1, 2).then(console.log);
returns(3, 4).then(console.log);
throws(5, 6).catch(console.error);
Promise.resolve().then(() => console.log("Promise.resolve"));
console.log("All functions called");
Die Ausgabe lautet:
awaits() starts returns() starts throws() starts All functions called 7 Error: 5 and 6 Promise.resolve 3
Wie Sie sehen, beginnen alle Funktionen ihre Ausführung synchron. Die von returns(3, 4) und throws(5, 6) zurückgegebenen Promises werden unmittelbar bei der Rückkehr aus den Funktionen erfüllt beziehungsweise zurückgewiesen, da die Funktionen kein await enthalten. Deshalb wird ihre Ausgabe vor der von Promise.resolve protokolliert. Das Ergebnis von awaits() liegt erst vor, nachdem setTimeout nach 10 ms abgeschlossen ist.
Eine Generatorfunktion aufrufen
Generatorfunktionen geben Generator-Objekte zurück. Die Ausführung der Funktion wird ausgesetzt, bis next() aufgerufen wird.
function* yieldTwo(a, b) {
yield a;
yield b;
return "done";
}
const gen = yieldTwo(1, 2);
console.log(gen.next()); // {value: 1, done: false}
console.log(gen.next()); // {value: 2, done: false}
console.log(gen.next()); // {value: "done", done: true}
Weitere Informationen zur Funktionsweise finden Sie im Leitfaden Iteratoren und Generatoren.
Eine asynchrone Generatorfunktion aufrufen
Asynchrone Generatorfunktionen geben AsyncGenerator-Objekte zurück. Die Ausführung der Funktion wird ausgesetzt, bis next() aufgerufen wird.
async function* yieldTwo(a, b) {
await new Promise((resolve) => setTimeout(resolve, 10));
yield a;
await new Promise((resolve) => setTimeout(resolve, 10));
yield b;
await new Promise((resolve) => setTimeout(resolve, 10));
return "done";
}
const gen = yieldTwo(1, 2);
console.log(await gen.next()); // {value: 1, done: false}
console.log(await gen.next()); // {value: 2, done: false}
console.log(await gen.next()); // {value: "done", done: true}