Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

Nullish-Coalescing-Operator (??)

Baseline
Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2020 browserübergreifend verfügbar.

Der Nullish-Coalescing-Operator (??) ist ein logischer Operator, der seinen rechten Operanden zurückgibt, wenn sein linker Operand null oder undefined ist. Andernfalls gibt er seinen linken Operanden zurück.

Probieren Sie es aus

const foo = null ?? "default string";
console.log(foo);
// Expected output: "default string"

const baz = 0 ?? 42;
console.log(baz);
// Expected output: 0

Syntax

js
leftExpr ?? rightExpr

Beschreibung

Der Nullish-Coalescing-Operator kann als Sonderfall des logischen ODER-Operators (||) betrachtet werden. Dieser gibt den rechten Operanden zurück, wenn der linke Operand ein beliebiger falsy-Wert ist, nicht nur null oder undefined. Wenn Sie also || verwenden, um einer Variablen foo einen Standardwert zuzuweisen, kann es zu unerwartetem Verhalten kommen, falls Sie bestimmte falsy-Werte (z. B. '' oder 0) als gültig betrachten. Weitere Beispiele finden Sie weiter unten.

Der Nullish-Coalescing-Operator hat die fünftniedrigste Operatorrangfolge: direkt unter || und direkt über dem bedingten (ternären) Operator.

Die AND- (&&) und OR-Operatoren (||) können nicht direkt mit ?? kombiniert werden. In solchen Fällen wird ein Syntaxfehler ausgelöst.

js
null || undefined ?? "foo"; // raises a SyntaxError
true && undefined ?? "foo"; // raises a SyntaxError

Verwenden Sie stattdessen Klammern, um die Rangfolge ausdrücklich festzulegen:

js
(null || undefined) ?? "foo"; // returns "foo"

Beispiele

Den Nullish-Coalescing-Operator verwenden

In diesem Beispiel werden Standardwerte bereitgestellt, während andere Werte als null oder undefined beibehalten werden.

js
const nullValue = null;
const emptyText = ""; // falsy
const someNumber = 42;

const valA = nullValue ?? "default for A";
const valB = emptyText ?? "default for B";
const valC = someNumber ?? 0;

console.log(valA); // "default for A"
console.log(valB); // "" (as the empty string is not null or undefined)
console.log(valC); // 42

Einer Variablen einen Standardwert zuweisen

Früher wurde häufig der logische ODER-Operator (||) verwendet, um einer Variablen einen Standardwert zuzuweisen:

js
let foo;

// foo is never assigned any value so it is still undefined
const someDummyText = foo || "Hello!";

Da || jedoch ein boolescher logischer Operator ist, wurde der linke Operand für die Auswertung in einen booleschen Wert umgewandelt. Jeder falsy-Wert (einschließlich 0, '', NaN, false usw.) wurde deshalb nicht zurückgegeben. Dieses Verhalten kann unerwartete Folgen haben, wenn Sie 0, '' oder NaN als gültige Werte betrachten.

js
const count = 0;
const text = "";

const qty = count || 42;
const message = text || "hi!";
console.log(qty); // 42 and not 0
console.log(message); // "hi!" and not ""

Der Nullish-Coalescing-Operator vermeidet dieses Problem, indem er den zweiten Operanden nur dann zurückgibt, wenn der erste Operand null oder undefined ergibt (nicht jedoch bei anderen falsy-Werten):

js
const myText = ""; // An empty string (which is also a falsy value)

const notFalsyText = myText || "Hello world";
console.log(notFalsyText); // Hello world

const preservingFalsy = myText ?? "Hi neighborhood";
console.log(preservingFalsy); // '' (as myText is neither undefined nor null)

Kurzschlussauswertung

Wie bei den logischen OR- und AND-Operatoren wird der rechte Ausdruck nicht ausgewertet, wenn der linke Operand weder null noch undefined ist.

js
function a() {
  console.log("a was called");
  return undefined;
}
function b() {
  console.log("b was called");
  return false;
}
function c() {
  console.log("c was called");
  return "foo";
}

console.log(a() ?? c());
// Logs "a was called" then "c was called" and then "foo"
// as a() returned undefined so both expressions are evaluated

console.log(b() ?? c());
// Logs "b was called" then "false"
// as b() returned false (and not null or undefined), the right
// hand side expression was not evaluated

Zusammenspiel mit dem Optional-Chaining-Operator (?.)

Der Nullish-Coalescing-Operator behandelt undefined und null als spezielle Werte. Das gilt auch für den Optional-Chaining-Operator (?.), mit dem Sie auf eine Eigenschaft eines Objekts zugreifen können, das möglicherweise null oder undefined ist. Durch die Kombination beider Operatoren können Sie sicher auf eine Eigenschaft eines solchen Objekts zugreifen und einen Standardwert bereitstellen, falls die Eigenschaft null oder undefined ist.

js
const foo = { someFooProp: "hi" };

console.log(foo.someFooProp?.toUpperCase() ?? "not available"); // "HI"
console.log(foo.someBarProp?.toUpperCase() ?? "not available"); // "not available"

Spezifikationen

Spezifikation
ECMAScript® 2027 Language Specification
# prod-CoalesceExpression

Browser-Kompatibilität

Siehe auch