Skip to content

Commit a067367

Browse files
authored
Merge pull request #190 from behrends/Nullish-coalescing-operator
Nullish coalescing operator '??'
2 parents 038635e + 4b4c397 commit a067367

File tree

1 file changed

+58
-58
lines changed
  • 1-js/02-first-steps/12-nullish-coalescing-operator

1 file changed

+58
-58
lines changed
Lines changed: 58 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -1,94 +1,94 @@
1-
# Nullish coalescing operator '??'
1+
# Nullish Coalescing Operator '??'
22

33
[recent browser="new"]
44

5-
The nullish coalescing operator is written as two question marks `??`.
5+
Der Nullish Coalescing Operator wird als zwei Fragezeichen `??` geschrieben.
66

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.
88

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`.
1212

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.
1414

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.
1616

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:
1818

1919
```js
2020
result = (a !== null && a !== undefined) ? a : b;
2121
```
2222

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.
2424

25-
The common use case for `??` is to provide a default value.
25+
Der gebräuchlichste Anwendungsfall für `??` ist, einen Standardwert bereitzustellen.
2626

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`:
2828

2929
```js run
3030
let user;
3131

32-
alert(user ?? "Anonymous"); // Anonymous (user is undefined)
32+
alert(user ?? "Anonymous"); // Anonymous (user ist undefined)
3333
```
3434
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:
3636
3737
```js run
3838
let user = "John";
3939

40-
alert(user ?? "Anonymous"); // John (user is not null/undefined)
40+
alert(user ?? "Anonymous"); // John (user ist nicht null/undefined)
4141
```
4242
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.
4444
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.
4646
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.
4848
49-
Let's use the `??` operator for that:
49+
Verwenden wir hierfür den `??` Operator:
5050
5151
```js run
5252
let firstName = null;
5353
let lastName = null;
5454
let nickName = "Supercoder";
5555

56-
// shows the first defined value:
56+
// zeigt den ersten definierten Wert:
5757
*!*
5858
alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
5959
*/!*
6060
```
6161
62-
## Comparison with ||
62+
## Vergleich mit ||
6363
64-
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.
6565
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:
6767
6868
```js run
6969
let firstName = null;
7070
let lastName = null;
7171
let nickName = "Supercoder";
7272

73-
// shows the first truthy value:
73+
// zeigt den ersten wahrheitswerten Wert:
7474
*!*
7575
alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
7676
*/!*
7777
```
7878
79-
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.
8080
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.
8282
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.
8686
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.
8888
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.
9090
91-
For example, consider this:
91+
Nehmen wir zum Beispiel:
9292
9393
```js run
9494
let height = 0;
@@ -97,73 +97,73 @@ alert(height || 100); // 100
9797
alert(height ?? 100); // 0
9898
```
9999
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`.
104104
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.
106106
107-
## Precedence
107+
## Vorrang
108108
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).
110110
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 `+`, `*`.
112112
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:
114114
115115
```js run
116116
let height = null;
117117
let width = null;
118118

119-
// important: use parentheses
119+
// wichtig: Klammern verwenden
120120
let area = (height ?? 100) * (width ?? 50);
121121

122122
alert(area); // 5000
123123
```
124124
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.
126126
127127
```js
128-
// without parentheses
128+
// ohne Klammern
129129
let area = height ?? 100 * width ?? 50;
130130

131-
// ...works this way (not what we want):
131+
// ...funktioniert so (nicht was wir wollen):
132132
let area = height ?? (100 * width) ?? 50;
133133
```
134134
135-
### Using ?? with && or ||
135+
### Verwendung von ?? mit && oder ||
136136
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.
138138
139-
The code below triggers a syntax error:
139+
Der folgende Code löst einen Syntaxfehler aus:
140140
141141
```js run
142-
let x = 1 && 2 ?? 3; // Syntax error
142+
let x = 1 && 2 ?? 3; // Syntaxfehler
143143
```
144144
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.
146146
147-
Use explicit parentheses to work around it:
147+
Verwende klare Klammern, um dies zu umgehen:
148148
149149
```js run
150150
*!*
151-
let x = (1 && 2) ?? 3; // Works
151+
let x = (1 && 2) ?? 3; // Funktioniert
152152
*/!*
153153

154154
alert(x); // 2
155155
```
156156
157-
## Summary
157+
## Zusammenfassung
158158
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.
160160
161-
It's used to assign default values to variables:
161+
Er wird verwendet, um Standardwerte für Variablen zuzuweisen:
162162
163163
```js
164-
// set height=100, if height is null or undefined
164+
// setze height=100, wenn height null oder undefined ist
165165
height = height ?? 100;
166166
```
167167
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

Comments
 (0)