function

name

Der Funktionsname.

param Optional

Der Name eines formalen Parameters für die Funktion. Die maximale Anzahl von Argumenten variiert in verschiedenen Engines. Für die Syntax der Parameter siehe die Funktionsreferenz.

statements Optional

Die Anweisungen, die den Funktionskörper ausmachen.

Eine function-Deklaration erstellt ein Function-Objekt. Jedes Mal, wenn eine Funktion aufgerufen wird, gibt sie den Wert zurück, der durch die letzte ausgeführte return-Anweisung angegeben ist, oder undefined, wenn das Ende des Funktionskörpers erreicht wird. Siehe Funktionen für detaillierte Informationen zu Funktionen.

function-Deklarationen verhalten sich wie eine Mischung aus var und let:

• Wie let, im strikten Modus, sind Funktionsdeklarationen auf den am nächsten enthaltenen Block beschränkt.
• Wie let können Funktionsdeklarationen auf höchster Ebene eines Moduls oder innerhalb von Blöcken im strikten Modus nicht durch andere Deklarationen erneut deklariert werden.
• Wie var werden Funktionsdeklarationen auf höchster Ebene eines Skripts (strikt oder nicht strikt) zu Eigenschaften von globalThis. Funktionsdeklarationen auf höchster Ebene eines Skripts oder Funktionskörpers (strikt oder nicht strikt) können durch eine andere function oder var erneut deklariert werden.
• Wie beide, können Funktionsdeklarationen neu zugewiesen werden, aber Sie sollten dies vermeiden.
• Anders als bei beiden werden Funktionsdeklarationen gehoben zusammen mit ihrem Wert und können überall in ihrem Geltungsbereich aufgerufen werden.

Funktionen können bedingt deklariert werden — das heißt, eine Funktionsanweisung kann innerhalb einer if-Anweisung verschachtelt werden. Im nicht-strikten Modus sind die Ergebnisse jedoch je nach Implementierung inkonsistent.

console.log(
  `'foo' name ${
    "foo" in globalThis ? "is" : "is not"
  } global. typeof foo is ${typeof foo}`,
);
if (false) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' name is global. typeof foo is undefined
//
// In Firefox:
// 'foo' name is global. typeof foo is undefined
//
// In Safari:
// 'foo' name is global. typeof foo is function

Die Wirkung der Geltungsbereichs- und Hebungsmechanismen ändert sich nicht, unabhängig davon, ob der if-Block tatsächlich ausgeführt wird.

console.log(
  `'foo' name ${
    "foo" in globalThis ? "is" : "is not"
  } global. typeof foo is ${typeof foo}`,
);
if (true) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' name is global. typeof foo is undefined
//
// In Firefox:
// 'foo' name is global. typeof foo is undefined
//
// In Safari:
// 'foo' name is global. typeof foo is function

Im strikten Modus sind Funktionsdeklarationen auf Block-Ebene auf diesen Block beschränkt und werden an die Spitze des Blocks gehoben.

"use strict";

{
  foo(); // Logs "foo"
  function foo() {
    console.log("foo");
  }
}

console.log(
  `'foo' name ${
    "foo" in globalThis ? "is" : "is not"
  } global. typeof foo is ${typeof foo}`,
);
// 'foo' name is not global. typeof foo is undefined

Funktionsdeklarationen in JavaScript werden in den oberen Teil der umgebenden Funktion oder des globalen Geltungsbereichs gehoben. Sie können die Funktion verwenden, bevor Sie sie deklariert haben:

hoisted(); // Logs "foo"

function hoisted() {
  console.log("foo");
}

Beachten Sie, dass Funktionsausdrücke nicht gehoben werden:

notHoisted(); // TypeError: notHoisted is not a function

var notHoisted = function () {
  console.log("bar");
};

Ob function-Deklarationen im gleichen Geltungsbereich erneut deklariert werden können, hängt davon ab, in welchem Geltungsbereich sie sich befinden.

Auf der obersten Ebene eines Skripts verhalten sich function-Deklarationen wie var und können durch eine andere function oder var, aber nicht durch let, const oder class erneut deklariert werden.

function a(b) {}
function a(b, c) {}
console.log(a.length); // 2
let a = 2; // SyntaxError: Identifier 'a' has already been declared

Wenn function-Deklarationen durch var erneut deklariert werden, überschreibt der Initialisierer der var-Deklaration immer den Funktionswert, unabhängig von ihrer relativen Position. Dies liegt daran, dass Funktionsdeklarationen vor jeder Initialisierungsbewertung gehoben werden, sodass die Initialisierung später kommt und den Wert überschreibt.

var a = 1;
function a() {}
console.log(a); // 1

Auf der obersten Ebene des Funktionskörpers verhält sich function ebenfalls wie var und kann erneut deklariert werden oder denselben Namen wie ein Parameter haben.

function foo(a) {
  function a() {}
  console.log(typeof a);
}

foo(2); // Logs "function"

Auf der obersten Ebene eines Moduls oder eines Blocks im strikten Modus verhalten sich function-Deklarationen wie let und können nicht durch eine andere Deklaration erneut deklariert werden.

// Assuming current source is a module
function foo() {}
function foo() {} // SyntaxError: Identifier 'foo' has already been declared

"use strict";
{
  function foo() {}
  function foo() {} // SyntaxError: Identifier 'foo' has already been declared
}

Eine function-Deklaration innerhalb eines catch-Blocks kann nicht denselben Namen wie der durch catch gebundene Bezeichner haben, auch nicht im nicht-strikten Modus.

try {
} catch (e) {
  function e() {} // SyntaxError: Identifier 'e' has already been declared
}

Der folgende Code deklariert eine Funktion, die den Gesamtumsatz zurückgibt, wenn die Anzahl der verkauften Einheiten von drei Produkten angegeben wird.

function calcSales(unitsA, unitsB, unitsC) {
  return unitsA * 79 + unitsB * 129 + unitsC * 699;
}

• Leitfaden zu Funktionen
• Funktionen
• Function
• function Ausdruck
• function*
• async function
• async function*