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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
---
title: parseInt()
slug: Web/JavaScript/Reference/Global_Objects/parseInt
translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
---
<div>{{jsSidebar("Objects")}}</div>
<h2 id="Summary" name="Summary">Sumário</h2>
<p>A função <code><strong>parseInt()</strong></code> analisa um argumento <code>string</code> e retorna um inteiro na <code>base</code> especificada.</p>
<h2 id="Syntax" name="Syntax">Sintaxe</h2>
<pre class="syntaxbox">parseInt(<em>string</em>, <em>base</em>);</pre>
<h2 id="Parameters" name="Parameters">Parâmetros</h2>
<dl>
<dt><code>string</code></dt>
<dd>
<p>O valor a analisar. Se o argumento <code>string</code> não for uma string, então o valor é convertido para uma string (utilizando a operação abstrata <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Os espaços em branco na <code>string</code> são ignorados.</p>
</dd>
</dl>
<dl>
<dt><code>base</code></dt>
<dd>Um inteiro entre 2 e 36 que representa a <em>base</em> da <code>string (</code>sistemas numéricos matemáticos<code>) </code>mencionada no parâmetro anterior. Especifique <code>10</code> para o sistema numérico decimal comumente usado por humanos. <strong>Sempre especifique este parâmetro</strong> para eliminar confusão do leitor e para garantir o comportamento esperado. Implementações diferentes produzem resultados diferentes quando <code>base</code> não é especificado, normalmente assumindo o valor como 10.</dd>
</dl>
<h3 id="Valor_de_retorno">Valor de retorno</h3>
<p>Um número inteiro analisado a partir da string fornecida. Se o primeiro caracter não puder ser convertido para um número, {{jsxref("NaN")}} é retornado.</p>
<h2 id="Description" name="Description">Descrição</h2>
<p>A função <code>parseInt</code> converte seu primeiro argumento para uma string, analisa, e retorna um inteiro ou <code>NaN</code>. Se não <code>NaN</code>, o valor retornado será a representação decimal inteira do primeiro argumento obtido como um número na base especificada. Por exemplo, uma<em>base</em> 10 indica para converter de um número decimal, 8 octal, 16 hexadecimal, e assim por diante. Para bases acima de <code>10</code>, as letras do alfabeto indicam numerais maiores que <code>9</code>. Por exemplo, para números hexadecimais (base 16), <code>A</code> até <code>F</code> são usados.</p>
<p>Se <code>parseInt</code> encontrar um caracter que não seja um numeral na base especificada, ele o ignora e a todos os caracteres subsequentes e retorna o valor inteiro analisado até aquele ponto. <code>parseInt</code> trunca números para valores inteiros. Espaços no início e fim são permitidos.</p>
<p>Se <var>base</var> é <code>undefined</code> ou 0 (ou ausente), JavaScript assume o seguinte:</p>
<ul>
<li>Se a <code>string</code> de entrada começa com "0x" ou "0X", a <var>base</var> é 16 (hexadecimal) e o restante da string é analisado.</li>
<li>Se a <code>string</code> de entrada começa com "0", a <var>base</var> é oito (octal) ou 10 (decimal). Exatamente qual base é escolhida é dependente da implementação. O ECMAScript 5 especifica que 10 (decimal) seja utilizado, mas nem todos os browsers suportam isso ainda. Por essa razão <strong>sempre especifique uma base quando estiver usando <code>parseInt</code></strong>.</li>
<li>Se a <code>string</code> de entrada começa com qualquer outro valor, a base é 10 (decimal).</li>
</ul>
<p>Se o primeiro caracter não puder ser convertido para um número, <code>parseInt</code> retorna <code>NaN</code>.</p>
<p>Para propósitos aritméticos, o valor <code>NaN</code> não é um número em qualquer base. Você pode chamar a função {{jsxref("Global_Objects/isNaN", "isNaN")}} para determinar se o resultado de <code>parseInt</code> é <code>NaN</code>. Se <code>NaN</code> for passado em operações aritméticas, o resultado da operação também será <code>NaN</code>.</p>
<p>Para converter um número para seu literal string em uma base específica use <code>intValue.toString(base)</code>.</p>
<h2 id="Examples" name="Examples">Exemplos</h2>
<h3 id="Example:_Using_parseInt" name="Example:_Using_parseInt">Exemplo: Usando <code>parseInt</code></h3>
<p>Os seguintes exemplos sempre retornam <strong><code>15</code></strong>:</p>
<pre>parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);
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>Os seguintes exemplos sempre retornam <strong><code>NaN</code></strong>:</p>
<pre>parseInt("Hello", 8); // Não é realmente um número
parseInt("546", 2); // Dígitos não são válidos para representações binárias
</pre>
<p>Os seguintes exemplos sempre retornam <strong><code>-15</code></strong>:</p>
<pre>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>O seguinte exemplo retorna <strong><code>224</code></strong>:</p>
<pre>parseInt("0e0", 16);
</pre>
<h2 id="Interpretação_octal_sem_informar_a_base">Interpretação octal sem informar a base</h2>
<p>Embora desencorajado pelo ECMAScript 3 e proibido pelo ECMAScript 5, muitas implementações interpretam uma string numérica começando com um <code>0</code> como octal. O exemplo abaixo pode ter um resultado octal, ou ele pode ter um resultado decimal. <strong>Sempre especifique uma base para evitar este comportamento não confiável.</strong></p>
<pre>parseInt("0e0"); // 0
parseInt("08"); // 0, '8' não é um dígito octal.
</pre>
<h3 id="O_ECMAScript_5_remove_a_interpretação_octal">O ECMAScript 5 remove a interpretação octal</h3>
<p>A especificação ECMAScript 5 da funcão <code>parseInt</code> não permite mais que as implementações tratem Strings começando com o caracter 0 como um valor octal. O ECMAScript 5 declara:</p>
<p>A função <code>parseInt</code> produz um valor inteiro ditado pela interpretação do conteúdo de uma argumento string de acordo com uma base específicada. Espaços em branco no início da string são ignorados. Se a base for undefined ou <code>0</code>, ela é assumida como <code>10</code> exceto quando o número começa com os pares de caracter <code>0x</code> or <code>0X</code>, e neste caso a base 16 é assumida. Se a base é <code>16</code>, o número pode também opcionalmente começar com os pares de caracter <code>0x</code> or <code>0X</code>.</p>
<p>Isto difere do ECMAScript 3, que desencoraja mas permite a interpretação octal.</p>
<p>Muitas implementações não adotaram este comportamento a partir de 2013, e porque browser antigos devem ser suportados, <strong>sempre especifique uma base</strong>.</p>
<h2 id="Uma_função_de_análise_mais_rigorosa">Uma função de análise mais rigorosa</h2>
<p><span id="result_box" lang="pt"><span class="hps">É</span> <span class="hps">útil</span> <span class="hps">em algum momento</span> <span class="hps">ter uma maneira</span> <span class="hps">mais rigorosa</span> <span class="hps">para analisar</span> <span class="hps">valores inteiros</span><span>.</span> <span class="hps">Expressões regulares podem</span> <span class="hps">ajudar:</span></span></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="Especificações">Especificações</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Especificação</th>
<th scope="col">Status</th>
<th scope="col">Comentário</th>
</tr>
<tr>
<td>ECMAScript 1st Edition.</td>
<td>Padrão</td>
<td>Definição inicial</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>
</tbody>
</table>
<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>
<p>{{ CompatibilityTable() }}</p>
<div id="compat-desktop">
<table class="compat-table">
<tbody>
<tr>
<th>Característica</th>
<th>Chrome</th>
<th>Firefox (Gecko)</th>
<th>Internet Explorer</th>
<th>Opera</th>
<th>Safari</th>
</tr>
<tr>
<td>Suporte básico</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
</tr>
</tbody>
</table>
</div>
<div id="compat-mobile">
<table class="compat-table">
<tbody>
<tr>
<th>Característica</th>
<th>Android</th>
<th>Chrome para Android</th>
<th>Firefox Mobile (Gecko)</th>
<th>IE Mobile</th>
<th>Opera Mobile</th>
<th>Safari Mobile</th>
</tr>
<tr>
<td>Suporte básico</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
<td>{{ CompatVersionUnknown() }}</td>
</tr>
</tbody>
</table>
</div>
<h2 id="See_Also" name="See_Also">Veja também</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>
|
