Standardparameter
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Standardparameter für Funktionen ermöglichen es, benannte Parameter mit Standardwerten zu initialisieren, wenn kein Wert oder undefined
übergeben wird.
Probieren Sie es aus
function multiply(a, b = 1) {
return a * b;
}
console.log(multiply(5, 2));
// Expected output: 10
console.log(multiply(5));
// Expected output: 5
Syntax
function fnName(param1 = defaultValue1, /* …, */ paramN = defaultValueN) {
// …
}
Beschreibung
In JavaScript haben Funktionsparameter standardmäßig den Wert undefined
. Es ist jedoch oft nützlich, einen anderen Standardwert festzulegen. Hier kommen Standardparameter ins Spiel.
Im folgenden Beispiel würde der Wert von b
, wenn kein Wert für b
bereitgestellt wird, undefined
sein. Bei der Berechnung von a * b
und dem Aufruf von multiply
würde NaN
zurückgegeben.
function multiply(a, b) {
return a * b;
}
multiply(5, 2); // 10
multiply(5); // NaN !
In der Vergangenheit war die allgemeine Strategie zur Festlegung von Standardwerten das Überprüfen der Parameterwerte im Funktionskörper, um einen Wert zuzuweisen, falls sie undefined
sind. Im folgenden Beispiel wird b
auf 1
gesetzt, wenn multiply
nur mit einem Argument aufgerufen wird:
function multiply(a, b) {
b = typeof b !== "undefined" ? b : 1;
return a * b;
}
multiply(5, 2); // 10
multiply(5); // 5
Mit Standardparametern sind solche Überprüfungen im Funktionskörper nicht mehr notwendig. Sie können nun 1
als Standardwert für b
direkt im Funktionskopf zuweisen:
function multiply(a, b = 1) {
return a * b;
}
multiply(5, 2); // 10
multiply(5); // 5
multiply(5, undefined); // 5
Parameter werden weiterhin von links nach rechts gesetzt, wobei Standardparameter überschrieben werden, selbst wenn später definierte Parameter keine Standardwerte haben.
function f(x = 1, y) {
return [x, y];
}
f(); // [1, undefined]
f(2); // [2, undefined]
Hinweis:
Der erste Standardparameter sowie alle Parameter danach tragen nicht zur length
der Funktion bei.
Die Initialisierungen von Standardparametern existieren in ihrem eigenen Scope, der ein Parent-Scope für den Scope ist, der für den Funktionskörper erstellt wird.
Das bedeutet, dass frühere Parameter in den Initialisierungen späterer Parameter referenziert werden können. Allerdings können Funktionen und Variablen, die im Funktionskörper deklariert werden, nicht von Standardwert-Parametern initialisiert werden; ein solcher Versuch führt zu einem Laufzeit-ReferenceError
. Dies gilt auch für mit var
deklarierte Variablen im Funktionskörper.
Zum Beispiel löst die folgende Funktion einen ReferenceError
aus, wenn sie aufgerufen wird, da der Standardwertparameter keinen Zugriff auf den Child-Scope des Funktionskörpers hat:
function f(a = go()) {
function go() {
return ":P";
}
}
f(); // ReferenceError: go is not defined
Diese Funktion gibt den Wert des Parameters a
aus, da die Variable var a
nur zum oberen Bereich des Scope des Funktionskörpers gehoben wird, nicht aber zum übergeordneten Scope der Parameterliste. Ihr Wert ist daher für b
nicht sichtbar.
function f(a, b = () => console.log(a)) {
var a = 1;
b();
}
f(); // undefined
f(5); // 5
Der Standardparameter erlaubt jede Art von Ausdruck, aber Sie können weder await
noch yield
verwenden, da diese eine Pause bei der Auswertung des Standardausdrucks erforderlich machen würden. Der Parameter muss synchron initialisiert werden.
async function f(a = await Promise.resolve(1)) {
return a;
}
Hinweis:
Der Standardparameter wird beim Funktionsaufruf ausgewertet, nicht bei deren Definition. Die Gültigkeit der Operatoren await
und yield
hängt daher von der Funktion selbst ab, nicht von der umgebenden Funktion. Zum Beispiel wird await
, wenn die aktuelle Funktion nicht async
ist, als Bezeichner geparst und folgt den normalen Regeln für Bezeichner, selbst wenn sich diese Funktion innerhalb einer async
Funktion befindet.
Beispiele
undefined
vs. andere falsy-Werte übergeben
Im zweiten Aufruf in diesem Beispiel, selbst wenn das erste Argument explizit auf undefined
gesetzt wird (nicht jedoch null
oder andere falsy Werte), bleibt der Wert des num
-Arguments der Standardwert.
function test(num = 1) {
console.log(typeof num);
}
test(); // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)
// test with other falsy values:
test(""); // 'string' (num is set to '')
test(null); // 'object' (num is set to null)
Auswertung zur Laufzeit
Das Standardargument wird zur Laufzeit ausgewertet. Anders als z. B. in Python wird bei jedem Funktionsaufruf ein neues Objekt erstellt.
function append(value, array = []) {
array.push(value);
return array;
}
append(1); // [1]
append(2); // [2], not [1, 2]
Dies gilt sogar für Funktionen und Variablen:
function callSomething(thing = something()) {
return thing;
}
let numberOfTimesCalled = 0;
function something() {
numberOfTimesCalled += 1;
return numberOfTimesCalled;
}
callSomething(); // 1
callSomething(); // 2
Frühere Parameter sind für spätere Standardparameter verfügbar
Parameter, die früher (weiter links) definiert wurden, sind für später definierte Standardparameter verfügbar:
function greet(name, greeting, message = `${greeting} ${name}`) {
return [name, greeting, message];
}
greet("David", "Hi"); // ["David", "Hi", "Hi David"]
greet("David", "Hi", "Happy Birthday!"); // ["David", "Hi", "Happy Birthday!"]
Diese Funktionalität kann wie folgt nachgeahmt werden, was zeigt, wie viele Randfälle behandelt werden:
function go() {
return ":P";
}
function withDefaults(
a,
b = 5,
c = b,
d = go(),
e = this,
f = arguments,
g = this.value,
) {
return [a, b, c, d, e, f, g];
}
function withoutDefaults(a, b, c, d, e, f, g) {
switch (arguments.length) {
case 0:
case 1:
b = 5;
case 2:
c = b;
case 3:
d = go();
case 4:
e = this;
case 5:
f = arguments;
case 6:
g = this.value;
}
return [a, b, c, d, e, f, g];
}
withDefaults.call({ value: "=^_^=" });
// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
withoutDefaults.call({ value: "=^_^=" });
// [undefined, 5, 5, ":P", {value:"=^_^="}, arguments, "=^_^="]
Zerlegte Parameter mit Standardwertzuweisung
Sie können Standardwertzuweisungen zusammen mit der Destrukturierungszuweisung verwenden.
Eine übliche Methode hierfür ist das Setzen eines leeren Objekts/einer leeren Liste als Standardwert für den destrukturierten Parameter; zum Beispiel: [x = 1, y = 2] = []
. So ist es möglich, der Funktion nichts zu übergeben und dennoch diese Werte vorab zu füllen:
function preFilledArray([x = 1, y = 2] = []) {
return x + y;
}
preFilledArray(); // 3
preFilledArray([]); // 3
preFilledArray([2]); // 4
preFilledArray([2, 3]); // 5
// Works the same for objects:
function preFilledObject({ z = 3 } = {}) {
return z;
}
preFilledObject(); // 3
preFilledObject({}); // 3
preFilledObject({ z: 2 }); // 2
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-function-definitions |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Default parameters | ||||||||||||||
Destructured parameter with default value assignment | ||||||||||||||
Parameters without defaults after default parameters |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support