Standardparameter

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 standardmig den Wert undefined. Es ist jedoch oft ntzlich, einen anderen Standardwert festzulegen. Hierbei helfen Standardparameter.

Im folgenden Beispiel, wenn kein Wert fr b bereitgestellt wird, wenn multiply aufgerufen wird, wre der Wert von b undefined, wenn a * b ausgewertet wird, und multiply wrde NaN zurckgeben.

function multiply(a, b) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5); // NaN !

Frher war es allgemein blich, Standardwerte zu setzen, indem man Parameterwerte im Funktionskrper testet und ihnen einen Wert zuweist, wenn 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 Prfungen im Funktionskrper nicht mehr notwendig. Nun kann 1 als Standardwert fr b im Funktionskopf zugewiesen werden:

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 und berschreiben Standardparameter selbst dann, wenn es sptere Parameter ohne Standardwerte gibt.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

Die Initialisierer der Standardparameter befinden sich in einem eigenen Gltigkeitsbereich, der ein Elternteil des fr den Funktionskrper erstellten Gltigkeitsbereichs ist.

Das bedeutet, dass frhere Parameter in den Initialisierern spterer Parameter referenziert werden knnen. Funktionen und Variablen, die im Funktionskrper deklariert sind, knnen jedoch nicht aus den Initialisierern der Standardwerte referenziert werden; ein Versuch dies zu tun fhrt zu einem Laufzeit-ReferenceError. Dies schliet auch mit var deklarierte Variablen im Funktionskrper ein.

Zum Beispiel wird die folgende Funktion einen ReferenceError auslsen, wenn sie aufgerufen wird, da der Standardparameterwert keinen Zugriff auf den Kind-Gltigkeitsbereich des Funktionskrpers hat:

function f(a = go()) {
  function go() {
    return ":P";
  }
}

f(); // ReferenceError: go is not defined

Diese Funktion wird den Wert des Parameters a ausgeben, da die Variable var a nur an den Anfang des fr den Funktionskrper erstellten Gltigkeitsbereichs gehoben wird und ihr Wert im Elternbereich, der fr die Parameterliste erstellt wird, nicht sichtbar ist.

function f(a, b = () => console.log(a)) {
  var a = 1;
  b();
}

f(); // undefined
f(5); // 5

Der Standardparameter erlaubt jeden Ausdruck, aber es kann nicht await oder yield verwendet werden, die die Auswertung des Standardausdrucks pausieren wrden. Der Parameter muss synchron initialisiert werden.

async function f(a = await Promise.resolve(1)) {
  return a;
}

Beispiele

undefined bergeben vs. andere falsy Werte

Im zweiten Aufruf in diesem Beispiel, selbst wenn das erste Argument explizit auf undefined gesetzt ist (jedoch nicht 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 Aufrufzeit

Das Standardargument wird zur Aufrufzeit ausgewertet. Anders als in Python (zum Beispiel) wird jedes Mal, wenn die Funktion aufgerufen wird, ein neues Objekt erstellt.

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); // [1]
append(2); // [2], not [1, 2]

Dies gilt auch fr Funktionen und Variablen:

function callSomething(thing = something()) {
  return thing;
}

let numberOfTimesCalled = 0;
function something() {
  numberOfTimesCalled += 1;
  return numberOfTimesCalled;
}

callSomething(); // 1
callSomething(); // 2

Frhere Parameter sind fr sptere Standardparameter verfgbar

Frher definierte Parameter (links) sind fr sptere Standardparameter verfgbar:

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 Funktionalitt kann so approximiert werden, was zeigt, wie viele Randflle 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, "=^_^="]

Destrukturierter Parameter mit Standardwertzuweisung

Sie knnen Standardwertzuweisungen mit der Destrukturierungs-Syntax verwenden.

Eine gngige Methode dafr ist, ein leeres Objekt/Array als Standardwert fr den destrukturierten Parameter festzulegen; zum Beispiel: [x = 1, y = 2] = []. Dies ermglicht es, der Funktion nichts zu bergeben und dennoch diese Werte vorausgefllt zu haben:

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

Browser-Kompatibilitt

Siehe auch

• Leitfaden fr Funktionen
• Funktionen
• Restparameter
• Nullish coalescing operator (??)