You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
The nullish coalescing operator is written as two question marks `??`.
5
+
Der Nullish Coalescing Operator wird als zwei Fragezeichen `??` geschrieben.
6
6
7
-
As it treats `null`and`undefined`similarly, we'll use a special term here, in this article. For brevity, we'll say that a value is "defined" when it's neither `null`nor`undefined`.
7
+
Da er `null`und`undefined`ähnlich behandelt, werden wir hier in diesem Artikel einen speziellen Begriff verwenden. Kurz gesagt, wir werden sagen, dass ein Wert "definiert" ist, wenn er weder `null`noch`undefined` ist.
8
8
9
-
The result of`a ?? b`is:
10
-
-if`a`is defined, then`a`,
11
-
-if`a`isn't defined, then`b`.
9
+
Das Ergebnis von`a ?? b`ist:
10
+
-wenn`a`definiert ist, dann`a`,
11
+
-wenn`a`nicht definiert ist, dann`b`.
12
12
13
-
In other words, `??`returns the first argument if it's not `null/undefined`. Otherwise, the second one.
13
+
Anders gesagt, `??`gibt das erste Argument zurück, wenn es nicht `null/undefined` ist und andernfalls das zweite.
14
14
15
-
The nullish coalescing operator isn't anything completely new. It's just a nice syntax to get the first "defined" value of the two.
15
+
Der Nullish Coalescing Operator ist nichts völlig Neues. Es ist nur eine nette Syntax, um den ersten "definierten" Wert von zweien zu bekommen.
16
16
17
-
We can rewrite `result = a ?? b`using the operators that we already know, like this:
17
+
Wir können `result = a ?? b`mit den Operatoren umschreiben, die wir bereits kennen, so:
18
18
19
19
```js
20
20
result = (a !==null&& a !==undefined) ? a : b;
21
21
```
22
22
23
-
Now it should be absolutely clear what `??`does. Let's see where it helps.
23
+
Jetzt sollte absolut klar sein, was `??`macht. Lass uns sehen, wo es hilft.
24
24
25
-
The common use case for `??`is to provide a default value.
25
+
Der gebräuchlichste Anwendungsfall für `??`ist, einen Standardwert bereitzustellen.
26
26
27
-
For example, here we show `user`if its value isn't `null/undefined`, otherwise`Anonymous`:
27
+
Beispielsweise zeigen wir hier `user`an, wenn sein Wert nicht `null/undefined` ist, ansonsten`Anonymous`:
28
28
29
29
```js run
30
30
let user;
31
31
32
-
alert(user ??"Anonymous"); // Anonymous (user is undefined)
32
+
alert(user ??"Anonymous"); // Anonymous (user ist undefined)
33
33
```
34
34
35
-
Here's the example with `user` assigned to a name:
35
+
Hier ist das Beispiel mit der Variablen `user`, der ein Name zugewiesen wurde:
36
36
37
37
```js run
38
38
let user ="John";
39
39
40
-
alert(user ??"Anonymous"); // John (user is not null/undefined)
40
+
alert(user ??"Anonymous"); // John (user ist nicht null/undefined)
41
41
```
42
42
43
-
We can also use a sequence of `??`to select the first value from a list that isn't `null/undefined`.
43
+
Wir können auch eine Sequenz von `??`verwenden, um den ersten Wert aus einer Liste auszuwählen, der nicht `null/undefined` ist.
44
44
45
-
Let's say we have a user's data in variables `firstName`, `lastName`or`nickName`. All of them may be not defined, if the user decided not to fill in the corresponding values.
45
+
Nehmen wir an, wir haben Daten eines Benutzers in den Variablen `firstName`, `lastName`oder`nickName`. Sie müssen nicht alle definiert sein, sollte sich der Benutzer dazu entscheiden, die Information nicht auszufüllen.
46
46
47
-
We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are `null/undefined`.
47
+
Wir möchten den Benutzernamen mit einer dieser Variablen anzeigen oder "Anonymous" zeigen, wenn alle `null/undefined` sind.
The OR`||`operator can be used in the same way as `??`, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
64
+
Der ODER`||`Operator kann auf die gleiche Weise wie `??` verwendet werden, was im [vorherigen Kapitel](info:logical-operators#or-finds-the-first-truthy-value) beschrieben wurde.
65
65
66
-
For example, in the code above we could replace `??`with`||`and still get the same result:
66
+
Zum Beispiel könnten wir in dem obigen Code `??`durch`||`ersetzen und würden immer noch dasselbe Ergebnis erhalten:
Historically, the OR `||`operator was there first. It's been there since the beginning of JavaScript, so developers were using it for such purposes for a long time.
79
+
Historisch gesehen war der ODER `||`Operator zuerst da. Er ist seit den Anfängen von JavaScript vorhanden, sodass Entwickler ihn seit langem für solche Zwecke verwendet haben.
80
80
81
-
On the other hand, the nullish coalescing operator `??`was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
81
+
Andererseits wurde der Nullish Coalescing Operator `??`erst kürzlich zu JavaScript hinzugefügt, aufgrund der Unzufriedenheit mit `||` unter Entwicklern.
82
82
83
-
The important difference between them is that:
84
-
- `||`returns the first *truthy* value.
85
-
- `??`returns the first *defined* value.
83
+
Der wichtigste Unterschied zwischen den beiden ist, dass:
84
+
- `||`den ersten *wahrheitswerten* Wert zurückgibt.
85
+
- `??`den ersten *definierten* Wert zurückgibt.
86
86
87
-
In other words, `||` doesn't distinguish between `false`, `0`, an empty string `""` and`null/undefined`. They are all the same -- falsy values. If any of these is the first argument of `||`, then we'll get the second argument as the result.
87
+
Anders gesagt, unterscheidet der `||`-Operator zwischen `false`, `0`, einer leeren Zeichenkette (`""`) und`null`/`undefined` nicht — sie werden gleichwertig betrachtet (falsy). Wenn einer dieser das erste Argument von `||` ist, dann erhalten wir als Ergebnis das zweite Argument.
88
88
89
-
In practice though, we may want to use default value only when the variable is`null/undefined`. That is, when the value is really unknown/not set.
89
+
In der Praxis jedoch möchten wir vielleicht nur dann einen Standardwert verwenden, wenn die Variable`null/undefined` ist. Das heißt, wenn der Wert wirklich unbekannt/nicht gesetzt ist.
90
90
91
-
For example, consider this:
91
+
Nehmen wir zum Beispiel:
92
92
93
93
```js run
94
94
let height =0;
@@ -97,73 +97,73 @@ alert(height || 100); // 100
97
97
alert(height ??100); // 0
98
98
```
99
99
100
-
- The `height ||100`checks`height`for being a falsy value, and it's `0`, falsy indeed.
101
-
- so the result of `||`is the second argument, `100`.
102
-
- The `height ??100`checks`height`for being `null/undefined`, and it's not,
103
-
- so the result is`height` "as is", that is`0`.
100
+
- `height ||100`prüft`height`darauf, ob es ein falsy Wert ist, und das ist `0`, eindeutig falsy.
101
+
- daher ist das Ergebnis von `||`das zweite Argument (`100`).
102
+
- `height ??100`prüft`height`darauf, ob es `null/undefined` ist, und das ist es nicht,
103
+
- daher ist das Ergebnis`height` "wie es ist", also`0`.
104
104
105
-
In practice, the zero height is often a valid value, that shouldn't be replaced with the default. So `??`does just the right thing.
105
+
In der Praxis ist die Höhe von Null oft ein gültiger Wert, der nicht durch den Standardwert ersetzt werden sollte. Daher macht `??`genau das Richtige.
106
106
107
-
## Precedence
107
+
## Vorrang
108
108
109
-
The precedence of the `??`operator is the same as `||`. They both equal`3` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
109
+
Die Vorrangigkeit des `??`Operators ist die gleiche wie bei `||`. Beide sind gleich`3` in der [MDN-Tabelle](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
110
110
111
-
That means that, just like `||`, the nullish coalescing operator`??`is evaluated before `=`and`?`, but after most other operations, such as`+`, `*`.
111
+
Das bedeutet, dass genau wie `||` der Nullish Coalescing Operator`??`vor `=`und`?` ausgewertet wird, aber nach den meisten anderen Operationen, wie`+`, `*`.
112
112
113
-
So we may need to add parentheses in expressions like this:
113
+
Also könnten wir gezwungen sein, Klammern in Ausdrücken wie diesem hinzuzufügen:
114
114
115
115
```js run
116
116
let height =null;
117
117
let width =null;
118
118
119
-
//important: use parentheses
119
+
//wichtig: Klammern verwenden
120
120
let area = (height ??100) * (width ??50);
121
121
122
122
alert(area); // 5000
123
123
```
124
124
125
-
Otherwise, if we omit parentheses, then as `*`has the higher precedence than `??`, it would execute first, leading to incorrect results.
125
+
Wenn wir die Klammern weglassen, würde `*`als höhere Priorität als `??` zuerst ausgeführt, was zu falschen Ergebnissen führen würde.
126
126
127
127
```js
128
-
//without parentheses
128
+
//ohne Klammern
129
129
let area = height ??100* width ??50;
130
130
131
-
// ...works this way (not what we want):
131
+
// ...funktioniert so (nicht was wir wollen):
132
132
let area = height ?? (100* width) ??50;
133
133
```
134
134
135
-
### Using ?? with && or ||
135
+
### Verwendung von ?? mit && oder ||
136
136
137
-
Due to safety reasons, JavaScript forbids using `??`together with`&&`and`||` operators, unless the precedence is explicitly specified with parentheses.
137
+
Aus Sicherheitsgründen verbietet JavaScript die Verwendung von `??`zusammen mit`&&`und`||`, es sei denn die Vorrangregeln werden durch Klammern explizit angegeben.
138
138
139
-
The code below triggers a syntax error:
139
+
Der folgende Code löst einen Syntaxfehler aus:
140
140
141
141
```js run
142
-
let x =1&&2??3; //Syntax error
142
+
let x =1&&2??3; //Syntaxfehler
143
143
```
144
144
145
-
The limitation is surely debatable, it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch from `||`to`??`.
145
+
Die Einschränkung ist sicher debattierbar, sie wurde der Sprachspezifikation hinzugefügt, um Programmierfehler zu vermeiden, wenn Leute beginnen, von `||`auf`??` umzusteigen.
146
146
147
-
Use explicit parentheses to work around it:
147
+
Verwende klare Klammern, um dies zu umgehen:
148
148
149
149
```js run
150
150
*!*
151
-
let x = (1&&2) ??3; //Works
151
+
let x = (1&&2) ??3; //Funktioniert
152
152
*/!*
153
153
154
154
alert(x); // 2
155
155
```
156
156
157
-
## Summary
157
+
## Zusammenfassung
158
158
159
-
- The nullish coalescing operator`??`provides a short way to choose the first "defined" value from a list.
159
+
- Der Nullish Coalescing Operator`??`bietet eine kurze Möglichkeit, den ersten "definierten" Wert aus einer Liste auszuwählen.
160
160
161
-
It's used to assign default values to variables:
161
+
Er wird verwendet, um Standardwerte für Variablen zuzuweisen:
162
162
163
163
```js
164
-
//set height=100, if height is null or undefined
164
+
//setze height=100, wenn height null oder undefined ist
165
165
height = height ??100;
166
166
```
167
167
168
-
- The operator`??`has a very low precedence, only a bit higher than `?`and`=`, so consider adding parentheses when using it in an expression.
169
-
- It's forbidden to use it with `||`or`&&`without explicit parentheses.
168
+
- Der Operator`??`hat eine sehr niedrige Vorrangigkeit, nur etwas höher als `?`und`=`, also sollte in Betracht gezogen werden, Klammern zu verwenden, wenn er in Ausdrücken verwendet wird.
169
+
- Es ist verboten, ihn mit `||`oder`&&`ohne explizite Klammern zu verwenden.
0 commit comments