Standardparameter — Keyword · JavaScript-Referenz

Signatur

function name(param1 = defaultValue1, /* …, */ paramN = defaultValueN) { /* … */ }

Beschreibung

Mit Standardparametern (Default Parameters) legen Sie direkt in der Parameterliste fest, welchen Wert ein Parameter bekommt, wenn der Aufrufer ihn weglässt. Vor ES2015 musste man das im Funktionsrumpf von Hand prüfen, etwa mit b = typeof b !== 'undefined' ? b : 1 oder dem fehleranfälligen b = b || 1. Heute schreiben Sie einfach function f(a, b = 1) {}.

Der Standardwert gilt nur bei undefined, also wenn das Argument fehlt oder ausdrücklich undefined übergeben wird. Andere falsy-Werte wie null, 0, '' oder false werden ganz normal übernommen und lösen den Standardwert nicht aus.

Der Standardausdruck wird bei jedem Aufruf neu ausgewertet (nicht nur einmal beim Definieren der Funktion wie in Python). Er darf beliebiges JavaScript enthalten: Funktionsaufrufe, Objekt- und Array-Literale und Verweise auf weiter links stehende Parameter. Die Parameter haben einen eigenen Gültigkeitsbereich und werden von links nach rechts initialisiert. Wer auf einen Parameter weiter rechts zugreift, landet in der Temporal Dead Zone und bekommt einen ReferenceError.

Standardparameter lassen sich gut mit Destrukturierung kombinieren. So entstehen Options-Objekte mit Standardwerten für jede einzelne Eigenschaft. Das ist das übliche Muster für konfigurierbare Funktionen und Konstruktoren. Standardparameter gibt es in normalen Funktionen, Pfeilfunktionen, Methoden, Klassenkonstruktoren sowie in Generator- und async-Funktionen.

Parameter

Name	Typ	Default	Beschreibung
$paramN Pflicht	Bezeichner \| Destrukturierungsmuster		Name des Parameters oder ein Objekt- bzw. Array-Destrukturierungsmuster, das einen Standardwert bekommen soll.
$defaultValueN	any (beliebiger Ausdruck)	undefined	Ausdruck, der bei jedem Aufruf ausgewertet wird, wenn das Argument `undefined` ist. Er darf auf weiter links stehende Parameter und auf äußere Variablen zugreifen.

Rückgabewert

Typ

—

Beschreibung

Standardparameter sind Syntax und liefern selbst keinen Wert. Sie legen nur fest, mit welchem Wert der Parameter im Funktionsrumpf startet.

Beispiele

Grundlagen: fehlendes Argument und undefined

const multiply = (a, b = 1) => a * b;

console.log(multiply(5));            // b fehlt
console.log(multiply(5, undefined)); // ausdrücklich undefined
console.log(multiply(5, 2));
console.log(multiply(5, null));      // null wird zu 0 umgewandelt, kein Standardwert!

5 5 10 0

Options-Objekt mit Destrukturierung und Standardwerten

async function fetchJson(url, {
  method = 'GET',
  timeout = 5000,
  headers = { Accept: 'application/json' }
} = {}) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeout);
  try {
    const res = await fetch(url, { method, headers, signal: controller.signal });
    return await res.json();
  } finally {
    clearTimeout(timer);
  }
}

// Alle drei Aufrufe funktionieren – dank "= {}" auch ganz ohne Optionen:
fetchJson('/api/users');
fetchJson('/api/users', { timeout: 1000 });
fetchJson('/api/users', { method: 'POST' });

Auswertung bei jedem Aufruf (kein geteilter Zustand)

const append = (value, list = []) => {
  list.push(value);
  return list;
};

console.log(append(1));
console.log(append(2)); // neues Array, anders als in Python

[ 1 ] [ 2 ]

Frühere Parameter verwenden und Pflichtparameter erzwingen

const required = (name) => {
  throw new TypeError(`Parameter "${name}" fehlt`);
};

function createUser(name = required('name'), slug = name.toLowerCase().replaceAll(' ', '-')) {
  return { name, slug };
}

console.log(createUser('Max Mustermann'));
try {
  createUser();
} catch (err) {
  console.log(err.message);
}

{ name: 'Max Mustermann', slug: 'max-mustermann' } Parameter "name" fehlt

Standardwert mitten in der Parameterliste

function greet(greeting = 'Hallo', name) {
  return `${greeting}, ${name}!`;
}

console.log(greet(undefined, 'Anna')); // undefined muss ausdrücklich übergeben werden
console.log(greet('Moin', 'Tom'));

Hallo, Anna! Moin, Tom!

// Wichtig · Fallstricke

Nur undefined löst den Standardwert aus. null, 0, false und '' werden übernommen. Soll auch null ersetzt werden, schreiben Sie im Rumpf param ??= wert.
Temporal Dead Zone: function f(a = b, b = 1) {} wirft beim Aufruf f() einen ReferenceError, weil b noch nicht initialisiert ist. Sie dürfen nur auf Parameter weiter links zugreifen.
Eigener Gültigkeitsbereich: Standardausdrücke sehen keine Variablen oder Funktionen, die erst im Funktionsrumpf deklariert werden. Eine Funktion, die im Rumpf deklariert ist, lässt sich im Standardwert also nicht aufrufen.
function.length zählt nur die Parameter vor dem ersten Parameter mit Standardwert: ((a, b = 1, c) => {}).length === 1. Bibliotheken, die sich auf length verlassen (z. B. beim Currying), können dadurch anders reagieren.
arguments: Hat eine Funktion Standardparameter, ist arguments nicht mehr mit den Parametern verknüpft, auch im Sloppy Mode nicht. Außerdem darf der Funktionsrumpf dann kein 'use strict' enthalten (SyntaxError).
Destrukturierung ohne = {}: Bei function f({ a = 1 }) {} wirft f() einen TypeError, weil undefined nicht destrukturiert werden kann. Hängen Sie deshalb immer = {} an das Muster an.
Standardausdrücke mit Nebenwirkungen (z. B. id = counter++) laufen bei jedem Aufruf ohne Argument erneut. Das ist gewollt, sollte aber bewusst eingesetzt werden.
Unterstützt von allen modernen Browsern und Node.js 6+, nicht vom Internet Explorer.

Siehe auch

Nullish Coalescing Operator (??) Function.prototype.length function Rest-Parameter new.target