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
Most of the time, operators and functions automatically convert the values given to them to the right type.
3
+
Meistens wandeln die Operatoren und Funktionen die Werte, die ihnen übergeben werden automatisch in den richtigen Datentyp um.
4
4
5
-
For example, `alert`automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
5
+
Zum Beispiel wandelt `alert`automatisch jeden Wert in den Datentyp "String" um (Zeichenkette), um ihn anzuzeigen. Mathematische Operationen wandeln Werte in Zahlen um.
6
6
7
-
There are also cases when we need to explicitly convert a value to the expected type.
7
+
Es gibt auch Fälle, in denen wir einen Wert explizit in den erwarteten Datentyp umwandeln müssen.
8
8
9
-
```smart header="Not talking about objects yet"
10
-
In this chapter, we won't cover objects. Instead, we'll study primitives first. Later, after we learn about objects, we'll see how object conversion works in the chapter <info:object-toprimitive>.
9
+
```smart header="Wir sprechen noch nicht über Objekte"
10
+
In diesem Kapitel werden wir keine Objekte behandeln. Stattdessen werden wir uns zuerst die primitiven Datentypen ansehen. Später, nachdem wir mehr über Objekte gelernt haben, werden wir im Kapitel <info:object-toprimitive> sehen, wie die Objektumwandlung funktioniert.
11
11
```
12
12
13
-
## String Conversion
13
+
## String Umwandlung
14
14
15
-
String conversion happens when we need the string form of a value.
15
+
String Umwandlung passiert immer dann, wann wir den Wert in Form einer Zeichenkette ("String") benötigen.
16
16
17
-
For example, `alert(value)`does it to show the value.
17
+
Zum Beispiel, `alert(value)`verwendet die String Umwandlung, um den Wert anzuzeigen.
18
18
19
-
We can also call the`String(value)`function to convert a value to a string:
19
+
Wir können auch die Funktion`String(value)`aufrufen, um einen Wert in einen String zu konvertieren:
20
20
21
21
```js run
22
22
let value =true;
23
23
alert(typeof value); // boolean
24
24
25
25
*!*
26
-
value =String(value); //now value is a string "true"
26
+
value =String(value); //jetzt ist der Wert ein String "true"
27
27
alert(typeof value); // string
28
28
*/!*
29
29
```
30
30
31
-
String conversion is mostly obvious. A`false`becomes `"false"`, `null`becomes `"null"`, etc.
31
+
Die String Umwandlung ist meist offensichtlich. Ein`false`wird zu `"false"`, `null`wird zu `"null"`, usw.
32
32
33
-
## Numeric Conversion
33
+
## Numerische Umwandlungen
34
34
35
-
Numeric conversion happens in mathematical functions and expressions automatically.
35
+
Numerische Umwandlung passiert automatisch in mathematischen Funktionen und Ausdrücken.
36
36
37
-
For example, when division `/`is applied to non-numbers:
37
+
Zum Beispiel, wenn die Division `/`an Werten angewendet wird, die keine Zahlen ("Number") sind:
38
38
39
39
```js run
40
-
alert( "6"/"2" ); // 3, strings are converted to numbers
40
+
alert( "6"/"2" ); // 3, weil die Strings zu Zahlen (Number) umgewandelt werden
41
41
```
42
42
43
-
We can use the `Number(value)`function to explicitly convert a `value` to a number:
43
+
Wir können explizit die Funktion `Number(value)`aufrufen, um einen Wert in eine Number (Zahl) zu konvertieren:
44
44
45
45
```js run
46
46
let str ="123";
47
47
alert(typeof str); // string
48
48
49
-
let num =Number(str); //becomes a number 123
49
+
let num =Number(str); //wird zu Number 123
50
50
51
51
alert(typeof num); // number
52
52
```
53
53
54
-
Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
54
+
Eine explizite Umwandlung ist normalerweise erforderlich, wenn wir einen Wert aus einer String-basierten Quelle wie einem Textfeld lesen, aber die Eingabe einer Zahl erwarten.
55
55
56
-
If the string is not a valid number, the result of such a conversion is`NaN`. For instance:
56
+
Wenn der String keine valide Zahl ("number") ist, dann ist das Ergebnis einer solchen Umwandlung`NaN`. Zum Beispiel:
57
57
58
58
```js run
59
-
let age =Number("an arbitrary string instead of a number");
59
+
let age =Number("ein beliebiger String anstatt einer Zahl");
|`string`|Whitespaces from the start and end are removed. If the remaining string is empty, the result is`0`. Otherwise, the number is "read" from the string. An error gives`NaN`. |
|`string`|Leerzeichen am Anfang und am Ende werden entfernt. Wenn der verbleibende String leer ist, ist das Ergebnis`0`. Andernfalls wird die Zahl aus dem String "gelesen". Ein Fehler ergibt`NaN`. |
72
72
73
-
Examples:
73
+
Beispiele:
74
74
75
75
```js run
76
76
alert( Number(" 123 ") ); // 123
77
-
alert( Number("123z") ); // NaN (error reading a number at "z")
77
+
alert( Number("123z") ); // NaN (Fehler beim Einlesen einer Zahl "z")
78
78
alert( Number(true) ); // 1
79
79
alert( Number(false) ); // 0
80
80
```
81
81
82
-
Please note that `null`and`undefined`behave differently here: `null`becomes zero while `undefined`becomes `NaN`.
82
+
Bitte beachte, dass sich `null`und`undefined`hier unterschiedlich verhalten: Aus `null`wird 0, während aus `undefined``NaN` wird.
83
83
84
-
Most mathematical operators also perform such conversion, we'll see that in the next chapter.
84
+
Die meisten mathematischen Operatoren führen auch solche Umwandlungen durch, wir werden das im nächsten Kapitel sehen.
85
85
86
-
## Boolean Conversion
86
+
## Boolean Umwandlung
87
87
88
-
Boolean conversion is the simplest one.
88
+
Boolean Umwandlung ist die einfachste.
89
89
90
-
It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
90
+
Sie geschieht in logischen Operationen (später treffen wir auf bedingte Anweisungen und ähnliche Dinge), kann aber auch mit `Boolean(value)` explizit aufgerufen werden.
91
91
92
-
The conversion rule:
92
+
Umwandlungsregel:
93
93
94
-
-Values that are intuitively "empty", like`0`, an empty string, `null`, `undefined`, and`NaN`, become`false`.
95
-
-Other values become`true`.
94
+
-Werte, die intuitiv "leer" sind, wie`0`, ein leerer string, `null`, `undefined`, und`NaN`, werden zu`false`.
````warn header="Please note: the string with zero `\"0\"`is`true`"
108
-
Some languages (namely PHP) treat `"0"`as`false`. But in JavaScript, a non-empty string is always`true`.
107
+
````warn header="Beachte: der string mit einer Null `\"0\"`ist`true`"
108
+
Einige Sprachen (namentlich PHP) behandeln die `"0"`als`false`. Aber in JavaScript ist ein nicht leerer String immer`true`.
109
109
110
110
```js run
111
111
alert( Boolean("0") ); // true
112
-
alert( Boolean("") ); //spaces, also true (any non-empty string is true)
112
+
alert( Boolean("") ); //Leerzeichen, auch true (jeder nicht leere String ist true)
113
113
```
114
114
````
115
115
116
-
## Summary
116
+
## Zusammenfassung
117
117
118
-
The three most widely used type conversions are to string, to number, and to boolean.
118
+
Die drei am weitesten verbreiteten Umwandlungen von Datentypen sind in String, in Number und in Boolean.
119
119
120
-
**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
120
+
**`String Umwandlung`** -- Tritt auf, wenn wir etwas ausgeben. Kann mit `String(value)` durchgeführt werden. Die Umwandlung in String ist für primitive Werte normalerweise offensichtlich.
121
121
122
-
**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
122
+
**`Numerische Umwandlung`** -- Tritt in mathematischen Operationen auf. Kann mit `Number(value)` ausgeführt werden.
123
123
124
-
The conversion follows the rules:
124
+
Die Umwandlung folgt diesen Regeln:
125
125
126
-
| Value | Becomes... |
126
+
| Wert | Wird zu... |
127
127
|-------|-------------|
128
128
|`undefined`|`NaN`|
129
129
|`null`|`0`|
130
130
|<code>true / false</code> | `1 / 0` |
131
-
| `string` | The string is read "as is", whitespaces from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
131
+
| `string` | Der String wird "als solches" gelesen, Leerzeichen auf beiden Seiten werden ignoriert. Ein leerer String wird zu `0`. Ein Fehler ergibt `NaN`. |
132
132
133
-
**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
133
+
**`Boolean Umwandlung`** -- Tritt in logischen Operationen auf. Kann mit `Boolean(value)` explizit ausgeführt werden.
134
134
135
-
Follows the rules:
135
+
Folgt den Regeln:
136
136
137
-
| Value | Becomes... |
137
+
| Wert | Wird zu... |
138
138
|-------|-------------|
139
139
|`0`, `null`, `undefined`, `NaN`, `""` |`false`|
140
-
|any other value| `true` |
140
+
|jeder andere Wert| `true` |
141
141
142
142
143
-
Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
143
+
Die meisten dieser Regeln sind leicht zu verstehen und zu merken. Die bemerkenswerten Ausnahmen, bei denen normalerweise Fehler gemacht werden, sind:
144
144
145
-
- `undefined` is `NaN` as a number, not `0`.
146
-
- `"0"` and space-only strings like `" "` are true as a boolean.
145
+
- `undefined` ist `NaN` als number, nicht `0`.
146
+
- `"0"` und Leerzeichen-Strings wie `" "` sind als boolean `true`.
147
147
148
-
Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
148
+
Objekte werden hier nicht abgedeckt. Wir werden später, im Kapitel <info:object-toprimitive>, darauf zurückkommen, wenn wir mehr grundlegende Dinge über JavaScript gelernt haben. Dieses Kapitel ist ausschließlich den Objekten gewidmet.
0 commit comments