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
196
197
198
199
200
201
202
|
---
title: parseInt()
slug: Web/JavaScript/Reference/Global_Objects/parseInt
tags:
- JavaScript
- Reference
translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
---
<div>
<div>
<div>{{jsSidebar("Objects")}}</div>
</div>
</div>
<p>Функция <code><strong>parseInt()</strong></code> принимает строку в качестве аргумента и возвращает целое число в соответствии с указанным основанием системы счисления.</p>
<p> </p>
<p>{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}</p>
<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
<p> </p>
<h2 id="Syntax" name="Syntax">Синтаксис</h2>
<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre>
<h3 id="Parameters" name="Parameters">Параметры</h3>
<dl>
<dt><code>string</code></dt>
<dd>Значение, которое необходимо проинтерпретировать. Если значение параметра <code>string</code> не принадлежит строковому типу, оно преобразуется в него (с помощью абстрактной операции <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Пробелы в начале строки не учитываются.</dd>
</dl>
<dl>
<dt><code>radix</code></dt>
<dd>Целое число в диапазоне между 2 и 36, представляющее собой основание системы счисления числовой строки <code>string</code>, описанной выше. В основном пользователи используют десятичную систему счисления и указывают 10. <strong>Всегда указывайте этот параметр,</strong> чтобы исключить ошибки считывания и гарантировать корректность исполнения и предсказуемость результата. Когда основание системы счисления не указано, разные реализации могут возвращать разные результаты.</dd>
</dl>
<h3 id="Description" name="Description">Возвращаемое значение</h3>
<p>Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ не получилось сконвертировать в число, то возвращается {{jsxref("NaN")}}. </p>
<h2 id="Description" name="Description">Описание</h2>
<p>Функция <code>parseInt</code> преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение <code>NaN</code>. Результат (если не <code>NaN</code>) является целым числом и представляет собой первый аргумент (<code>string</code>), рассматривающийся как число в указанной системе счисления (<code>radix</code>). Например, основание 10 указывает на преобразование из десятичного числа, 8 - восьмеричного, 16 - шестнадцатеричного и так далее. Если основание больше <code>10</code>, то для обозначения цифр больше <code>9</code> используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от <code>A</code> до <code>F</code>.</p>
<p>Если функция <code>parseInt</code> встречает символ, не являющийся числом в указанной системе счисления, она пропускает этот и все последующие символы (даже, если они подходящие) и возвращает целое число, преобразованное из части строки, предшествовавшей этому символу. <code>parseInt</code> отсекает дробную часть числа. Пробелы в начале и конце строки разрешены.</p>
<p>Так как некоторые числа включают символ <code>e</code> в своём строковом представлении (например, <strong><code>6.022e23</code></strong>), то использование <code>parseInt</code> для усечения числовых значений может дать неожиданные результаты, когда используются очень малые или очень большие величины. <code>parseInt</code> не должна использоваться как замена для {{jsxref("Math.floor()")}}.</p>
<p>Если основание системы счисления имеет значение <code>undefined</code> (не определено) или равно 0 (или не указано), то JavaScript по умолчанию предполагает следующее:</p>
<ul>
<li>Если значение входного параметра <code>string</code> начинается с "<code>0x</code>" или "<code>0X</code>", <var>за основание системы счисления принимается 16, и интерпретации подвергается оставшаяся часть строки.</var></li>
<li>Если значение входного параметра <code>string</code> начинается с "0", <var>за основание системы счисления принимается либо 8, либо 10, в зависимости от конкретной реализации.</var> В спецификации ECMAScript 5 прописано использование 10 (десятичная система), но это поддерживается ещё не всеми браузерами, поэтому необходимо <strong>всегда указывать основание системы счисления при использовании функции </strong><strong><code>parseInt</code></strong>.</li>
<li>Если значение входного параметра <code>string</code> начинается с любого другого символа, система счисления считается десятичной (основание 10).</li>
</ul>
<p>Если первый символ строки не может быть преобразован в число, <code>parseInt</code> возвращает значение <code>NaN</code>.</p>
<p>С точки зрения математики, значение <code>NaN</code> не является числом в какой-либо системе счисления. Чтобы определить, вернёт ли <code>parseInt </code>значение<code> </code><code>NaN </code>в качестве результата, можно вызвать функцию {{jsxref("Global_Objects/isNaN", "isNaN")}}. Если <code>NaN</code> участвует в арифметических операциях, результатом также будет <code>NaN</code>.</p>
<p>Для преобразования числа в строку в указанной системе счисления, используйте <code>intValue.toString(radix)</code>.</p>
<h2 id="Examples" name="Examples">Примеры</h2>
<h3 id="Example:_Using_parseInt" name="Example:_Using_parseInt">Пример: Использование <code>parseInt</code></h3>
<p>Все следующие примеры возвращают <strong><code>15</code></strong>:</p>
<pre class="brush: js">parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10); //parseInt(015, 10); вернёт 15
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);
</pre>
<p>Все следующие примеры возвращают <strong><code>NaN</code></strong>:</p>
<pre class="brush: js">parseInt("Hello", 8); // Не является числом
parseInt("546", 2); // Неверное число в двоичной системе счисления
</pre>
<p>Все следующие примеры возвращают <strong><code>-15</code></strong>:</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>Все следующие примеры возвращают <strong><code>4</code></strong>:</p>
<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="function token">parseInt</span><span class="punctuation token">(</span><span class="number token">4.7</span><span class="punctuation token">,</span> <span class="number token">10</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
<span class="function token">parseInt</span><span class="punctuation token">(</span><span class="number token">4.7</span> <span class="operator token">*</span> <span class="number token">1e22</span><span class="punctuation token">,</span> <span class="number token">10</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// Очень большие числа становятся 4</span>
<span class="function token">parseInt</span><span class="punctuation token">(</span><span class="number token">0.00000000000434</span><span class="punctuation token">,</span> <span class="number token">10</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// Очень маленькие числа становятся 4</span></code></pre>
<p>Следующий пример возвращает <strong><code>224</code></strong>:</p>
<pre class="brush: js">parseInt("0e0", 16);
</pre>
<h2 id="Восьмеричная_интерпретация_без_указания_системы_счисления">Восьмеричная интерпретация без указания системы счисления</h2>
<p>Хотя это не поощряется в спецификацией ECMAScript 3 и запрещено в ECMAScript 5, многие реализации интерпретируют числовую строку, начинающуюся с <code>0</code>, как восьмеричную. Следующий пример может иметь как восьмеричный, так и десятичный результат. <strong>Чтобы избежать непредвиденного результата, всегда указывайте основание системы счисления.</strong></p>
<pre class="brush: js">parseInt("0e0"); // 0
parseInt("08"); // 0, '8' не является цифрой в восьмеричной системе.
</pre>
<h3 id="ECMAScript_5_устраняет_восьмеричную_интерпретацию">ECMAScript 5 устраняет восьмеричную интерпретацию</h3>
<p>Спецификация ECMAScript 5 функции <code>parseInt</code> больше не разрешает трактовать в восьмеричной системе счисления строки, начинающиеся с <code>0</code>. ECMAScript 5 провозглашает:</p>
<p>Функция <code>parseInt</code> производит целочисленное значение в результате интерпретации содержимого строкового аргумента в соответствии с указанным основанием системы счисления. Пробел в начале строки не учитывается. Если основание системы счисления не определено или равно <code>0</code>, оно считается равным <code>10</code>, за исключением случаев, когда строка начинается с пар символов <code>0x</code> или <code>0X</code>: тогда за основание принимается 16. Если основанием системы счисления указано <code>16</code>, число также может начинаться с пар символов <code>0x</code> или <code>0X</code>.</p>
<p>В этом ECMAScript 5 расходится со спецификацией ECMAScript 3, в которой восьмеричная интерпретация не поощрялась, но и не была запрещена.</p>
<p>Поскольку на момент 2013 года описанное выше поведение было применено не во всех реализациях, а поддержка старых браузеров является необходимой, <strong>всегда указывайте основание системы счисления.</strong></p>
<h2 id="Более_строгая_функция_интерпретации">Более строгая функция интерпретации</h2>
<p>Иногда необходим более строгий способ интерпретации целочисленных значений. В этом могут помочь регулярные выражения:</p>
<pre class="brush: js">var 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="Спецификация">Спецификация</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Спецификация</th>
<th scope="col">Статус</th>
<th scope="col">Комментарий</th>
</tr>
<tr>
<td>{{SpecName('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Изначальное определение.</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="Поддержка_браузерами">Поддержка браузерами</h2>
<p>{{Compat("javascript.builtins.parseInt")}}</p>
<h2 id="See_Also" name="See_Also">Смотри также</h2>
<ul>
<li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
<li>{{jsxref("Number.parseFloat()")}}</li>
<li>{{jsxref("Number.parseInt()")}}</li>
<li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
<li>{{jsxref("Number.toString()")}}</li>
<li>{{jsxref("Object.valueOf")}}</li>
</ul>
|
