1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
---
title: parseInt()
slug: Web/JavaScript/Reference/Global_Objects/parseInt
tags:
- JavaScript
translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
---
<div>{{jsSidebar("Objects")}}</div>
<p>Die <strong><code>parseInt()</code></strong> Methode liest ein String-Argument ein und gibt eine ganze Zahl im angegebenen Zahlensystem zurück.</p>
<div>{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}</div>
<h2 id="Syntax">Syntax</h2>
<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre>
<h3 id="Parameter">Parameter</h3>
<dl>
<dt><code>string</code></dt>
<dd>Umzuwandelnder Wert. Wenn <code>string</code> kein String ist, wird er zu einem String konvertiert (durch die abstrakte Operation <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Führende Leerzeichen im String werden ignoriert.</dd>
</dl>
<dl>
<dt><code>radix</code></dt>
<dd>Eine ganze Zahl zwischen 2 und 36, die die Basis eines mathematischen Zahlensystems ist, in der der String geschrieben ist. 10 steht für das gebräuchliche Dezimalsystem.</dd>
</dl>
<h3 id="Rückgabewert">Rückgabewert</h3>
<p>Eine ganze Zahl des übergebenen Strings. Wenn das erste Zeichen nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p>
<h2 id="Beschreibung">Beschreibung</h2>
<p>Die <code>parseInt</code> Funktion konvertiert das erste Argument zu einem String, analysiert diesen und gibt eine ganze Zahl oder <code>NaN</code> zurück. Wenn nicht <code>NaN</code> zurückgegeben wird, ist der Wert des ersten Arguments eine gültige ganze Zahl im entsprechenden Zahlensystem. Zum Beispiel wird im 10er-Zahlensystem von einer Dezimalzahl ausgegangen, im 8er-System von einer Oktalzahl, im 16er-System von einer Hexadezimalzahl und so weiter. Für die Basis eines Zahlensystems größer als <code>10</code> sind Buchstaben des Alphabets Repräsentanten für Zahlen größer als <code>9</code>. Zum Beispiel werden für Hexadezimalezahlen (Basis 16) die Buchstaben <code>A</code> bis <code>F</code> eingesetzt.</p>
<p>Wenn <code>parseInt</code> ein Zeichen findet, welches keine Ziffer im spezifizierten Zahlensystem ist wird dieses und alle folgenden Zeichen ignoriert. <code>parseInt</code> schneidet Nachkommstellen ab. Führende und nachgestellte Leerzeichen sind erlaubt.</p>
<p>Weil einige Zahlen mit einem <code>e</code> Zeichen in ihrer String-Repräsentation (z. B. <strong><code>6.022e23</code></strong>), führt der Einsatz von <code>parseInt</code> zum Abschneiden von nummerischer Wert und unerwarteten Ergebnissen, wenn große oder kleine Zahlen verwendet werden. <code>parseInt</code> sollte nicht als Ersatz für {{jsxref("Math.floor()")}} eingesetzt werden.</p>
<p>Wenn <var>radix</var> <code>undefined</code> oder 0 ist (oder fehlt), nimmt JavaScript folgendes an:</p>
<ul>
<li>Wenn <code>string</code> mit <code>"0x"</code> oder <code>"0X"</code> beginnt, wird das Hexadezimalsystem verwendet.</li>
<li>Wenn <code>string</code> mit <code>"0"</code> beginnt, wird das Oktal- oder Dezimalsystem verwendet (Implementierungsabhängig). ECMAScript 5 spezifiziert das Dezimalsystem, jedoch unterstützen das nicht alle Browser. <strong>Deswegen sollte der Parameter <code>radix</code> immer angegeben werden</strong></li>
<li>Wenn <code>string</code> mit einem anderen Zeichen beginnt, wird das Dezimalsystem verwendet.</li>
</ul>
<p>Wenn das erste Zeichen nicht zu einer Zahl konvertiert werden kann, gibt <code>parseInt</code> <code>NaN</code> zurück.</p>
<p>Für arithmetische Zwecke ist <code>NaN</code> in keinem Zahlensystem eine Zahl. Man kann die Funktion {{jsxref("isNaN", "isNaN()")}} aufrufen, um zu prüfen, ob das Ergebnis von <code>parseInt</code> <code>NaN</code> ist. Wenn <code>NaN</code> in einer arithmetischen Operation eingesetzt wird, ist das Ergebnis auch immer <code>NaN</code>.</p>
<p>Um Zahlen in String-Repräsentationen in verschiedenen Zahlensystemen zu konvertieren nutze folgendes:<br>
<code>intValue.toString(radix)</code>.</p>
<h2 id="Beispiele">Beispiele</h2>
<h3 id="Einsatz_von_parseInt">Einsatz von <code>parseInt</code></h3>
<p>Alle folgenden Beispiele geben <strong><code>15</code> </strong>zurück:</p>
<pre class="brush: js">parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);
parseInt(15.99, 10);
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);
</pre>
<p>Alle folgenden Beispiele geben <code><strong>NaN</strong></code> zurück:</p>
<pre class="brush: js">parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits are not valid for binary representations
</pre>
<p>Alle folgenden Beispiele geben <code><strong>-15</strong></code> zurück:</p>
<pre class="brush: js">parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10);
parseInt(" -17", 8);
parseInt(" -15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);
</pre>
<p>Die folgenden Beispiele geben <code><strong>4</strong></code> zurück:</p>
<pre class="brush: js">parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); // Sehr große Zahl wird zu 4
parseInt(0.00000000000434, 10); // Sehr kleine Zahl wird zu 4</pre>
<p>Das folgende Beispiel gibt <strong><code>224</code></strong> zurück:</p>
<pre class="brush: js">parseInt("0e0", 16);
</pre>
<h2 id="Oktal-Interpretationen_ohne_radix">Oktal-Interpretationen ohne radix</h2>
<p>Obwohl ECMAScript 3 es nicht empfahl und ECMAScript 5 es verbietet, interpretieren viele Implementierungen einen mit <code>"0"</code> beginnende String als Oktalzahl. Das folgende Beispiel hat ein Ergebnis im Oktal- oder Dezimalsystem. <strong>Das Zahlensystem sollte immer angegeben werden, um solche Verwirrungen zu vermeiden.</strong></p>
<pre class="brush: js">parseInt("0e0"); // 0
parseInt("08"); // 0, '8' ist keine oktale Ziffer.
</pre>
<h3 id="ECMAScript_5_entfernt_oktale_Interpretation">ECMAScript 5 entfernt oktale Interpretation</h3>
<p>Die ECMAScript 5 Spezifikation der <code>parseInt</code> Funktion erlaubt es nicht mehr einen mit <code>0</code> beginnenden String als Oktalzahl zu interpretieren. ECMAScript 5 Stand:</p>
<p>Die <code>parseInt</code> Funktion produziert eine ganze Zahl, indem der Inhalt vom string Argument interpretiert wird, abhängig vom in radix angegebenen Zahlensystem. Führende Whitespaces werden ignoriert. Wenn radix <code>undefined</code> oder <code>0</code> ist, wird von <code>10</code> ausgegangen, außer die Zahl beginnt mit den Zeichen <code>0x</code> oder <code>0X</code>, dann wird <code>16</code> für radix angenommen.</p>
<p>Das unterscheidet sich von der ECMAScript 3 Spezifikation, welche Oktalinterpretationen nicht empfiehlt, sie aber erlaubt.</p>
<p>Weil viele Implementierungen dieses Verhalten seit 2013 nicht geändert haben und auch ältere Browser unterstützt werden müssen, <strong>sollte immer das radix-Argument gesetzt werden.</strong></p>
<h2 id="Eine_strenge_parse-Funktion">Eine strenge parse-Funktion</h2>
<p>Es ist manchmal nützliche eine strenge Funktion für die Umwandlung von ganzen Zahlen zu verwenden. Reguläre Ausdrücke können helfen:</p>
<pre class="brush: js">filterInt = function (value) {
if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value))
return Number(value);
return NaN;
}
console.log(filterInt('421')); // 421
console.log(filterInt('-421')); // -421
console.log(filterInt('+421')); // 421
console.log(filterInt('Infinity')); // Infinity
console.log(filterInt('421e+0')); // NaN
console.log(filterInt('421hop')); // NaN
console.log(filterInt('hop1.61803398875')); // NaN
console.log(filterInt('1.61803398875')); // NaN
</pre>
<h2 id="Spezifikationen">Spezifikationen</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Spezifikation</th>
<th scope="col">Status</th>
<th scope="col">Komment</th>
</tr>
<tr>
<td>{{SpecName('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Initiale Definition.</td>
</tr>
<tr>
<td>{{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}}</td>
<td>{{Spec2('ES5.1')}}</td>
<td> </td>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}}</td>
<td>{{Spec2('ES6')}}</td>
<td> </td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-parseint-string-radix', 'parseInt')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td> </td>
</tr>
</tbody>
</table>
<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
<p>{{Compat("javascript.builtins.parseInt")}}</p>
<h2 id="Siehe_auch">Siehe auch</h2>
<ul>
<li>{{jsxref("parseFloat", "parseFloat()")}}</li>
<li>{{jsxref("Number.parseFloat()")}}</li>
<li>{{jsxref("Number.parseInt()")}}</li>
<li>{{jsxref("isNaN", "isNaN()")}}</li>
<li>{{jsxref("Number.toString()")}}</li>
<li>{{jsxref("Object.valueOf")}}</li>
</ul>
|
