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
|
---
title: parseInt()
slug: Web/JavaScript/Reference/Global_Objects/parseInt
translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
---
<div>{{jsSidebar("Objects")}}</div>
<p>La funzione <code><strong>parseInt()</strong></code> analizza un argomento stringa e restituisce un numero intero della radice specificata (la base nei sistemi numerici matematici).</p>
<div>{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}</div>
<h2 id="Sintassi">Sintassi</h2>
<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre>
<h3 id="Parametri">Parametri</h3>
<dl>
<dt><code>string</code></dt>
<dd>Il valore da analizzare. Se l'argomento <code>string</code> non è una stringa, viene convertito in una stringa (utilizzando l'operazione astratta <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Gli spazi bianchi iniziali nell'argomento stringa vengono ignorati.</dd>
<dt><code>radix</code></dt>
<dd>Un numero intero compreso tra 2 e 36 che rappresenta la <em>radice</em> (la base nei sistemi numerici matematici) della stringa sopra menzionata.</dd>
</dl>
<h3 id="Valore_di_ritorno">Valore di ritorno</h3>
<p>Un numero intero analizzato dalla stringa specificata. Se il primo carattere non può essere convertito in un numero, viene restituito {{jsxref("NaN")}}.</p>
<h2 id="Descrizione">Descrizione</h2>
<p>La funzione <code>parseInt</code> converte il suo primo argomento in una stringa, lo analizza e restituisce un numero intero o <code>NaN</code>. Se non è <code>NaN</code>, il valore restituito sarà l'intero che è il primo argomento preso come numero nella <em>radice</em> specificata (base). Ad esempio, una <em>radice</em> di 10 indica la conversione da un numero decimale, 8 ottali, 16 esadecimali e così via. Per le radici sopra <code>10</code>, le lettere dell'alfabeto indicano numeri maggiori di <code>9</code>. Ad esempio, per i numeri esadecimali (base 16), vengono utilizzate le lettere da <code>A</code> a <code>F</code>.</p>
<p>Se <code>parseInt</code> incontra un carattere che non è un numero nella radice specificata, lo ignora e tutti i caratteri successivi e restituisce il valore intero analizzato fino a quel punto. <code>parseInt</code> tronca i numeri ai valori interi. Sono ammessi spazi iniziali e finali.</p>
<p>Poiché alcuni numeri includono il carattere <code>e</code> nella loro rappresentazione di stringa (ad esempio <strong><code>6.022e23</code></strong>), l'uso di <code>parseInt</code> per troncare valori numerici produrrà risultati imprevisti se utilizzato su numeri molto grandi o molto piccoli. <code>parseInt</code> non dovrebbe essere usato come sostituto di {{jsxref("Math.floor()")}}.</p>
<p>Se <em>radix</em> è <code>undefined</code> o 0 (o assente), JavaScript assume quanto segue:</p>
<ul>
<li>Se l'input <code>string</code> inizia con "0x" o "0X", radix è 16 (esadecimale) e il resto della stringa viene analizzato.</li>
<li>Se l'input <code>string</code> inizia con "0", radix è otto (ottale) o 10 (decimale). Esattamente quale radix è scelto dipende dall'implementazione. ECMAScript 5 specifica che viene utilizzato 10 (decimale), ma non tutti i browser lo supportano ancora. Per questo motivo <strong>specifica sempre una radice quando usi <code>parseInt</code></strong>.</li>
<li>Se l'input <code>string</code> inizia con qualsiasi altro valore, la radice è 10 (decimale).</li>
</ul>
<p>Se il primo carattere non può essere convertito in un numero, <code>parseInt</code> restituisce <code>NaN</code>.</p>
<p>Per scopi aritmetici, il valore <code>NaN</code> vnon è un numero in nessuna radice. È possibile chiamare la funzione {{jsxref("isNaN")}} per determinare se il risultato di <code>parseInt</code> è <code>NaN</code>. Se <code>NaN</code> viene passato alle operazioni aritmetiche, i risultati dell'operazione saranno anche <code>NaN</code>.</p>
<p>Per convertire il numero nella sua stringa letterale in una particolare radix, usa <code>intValue.toString(radix)</code>.</p>
<h2 id="Esempi">Esempi</h2>
<h3 id="Usare_parseInt">Usare parseInt</h3>
<p>Tutti gli esempi seguenti restituiscono <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); ritornerà 15
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>I seguenti esempi restituiscono tutti <strong><code>NaN</code></strong>:</p>
<pre class="brush: js">parseInt('Hello', 8); // Non è un numero
parseInt('546', 2); // Le cifre non sono valide per le rappresentazioni binarie
</pre>
<p>Tutti gli esempi seguenti restituiscono <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>Tutti gli esempi seguenti restituiscono <code><strong>4</strong></code>:</p>
<pre class="brush: js">parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); // Il numero molto grande diventa 4
parseInt(0.00000000000434, 10); // Il numero molto piccolo diventa 4
</pre>
<p>L'esempio seguente restituisce <code><strong>224</strong></code>:</p>
<pre class="brush: js">parseInt('0e0', 16);
</pre>
<h2 id="Interpretazioni_ottali_senza_radix">Interpretazioni ottali senza radix</h2>
<p>Sebbene scoraggiato da ECMAScript 3 e proibito da ECMAScript 5, molte implementazioni interpretano una stringa numerica che inizia con uno <code>0</code> iniziale come ottale. Il seguente potrebbe avere un risultato ottale o potrebbe avere un risultato decimale. <strong>Specifica sempre una radice per evitare questo comportamento inaffidabile.</strong></p>
<pre class="brush: js">parseInt('0e0'); // 0
parseInt('08'); // 0, '8' non è una cifra ottale.
</pre>
<h3 id="ECMAScript_5_rimuove_l'interpretazione_ottale">ECMAScript 5 rimuove l'interpretazione ottale</h3>
<p>La specifica ECMAScript 5 della funzione <code>parseInt</code> non consente più alle implementazioni di trattare le stringhe che iniziano con un carattere <code>0</code> come valori ottali. ECMAScript 5 afferma:</p>
<p>La funzione <code>parseInt</code> produce un valore intero dettato dall'interpretazione del contenuto dell'argomento stringa in base alla radice specificata. Lo spazio bianco principale nella stringa viene ignorato. Se radix non è definito o <code>0</code>, si presume che sia <code>10</code> tranne quando il numero inizia con le coppie di caratteri <code>0x</code> o <code>0X</code>, nel qual caso si assume una radice di 16.</p>
<p>Ciò differisce da ECMAScript 3, che scoraggiava, ma consentiva l'interpretazione ottale.</p>
<p>Molte implementazioni non hanno adottato questo comportamento a partire dal 2013 e, poiché i browser più vecchi devono essere supportati, <strong>specificare sempre una radice.</strong></p>
<h2 id="Una_funzione_di_analisi_più_rigorosa">Una funzione di analisi più rigorosa</h2>
<p>A volte è utile avere un modo più rigoroso di analizzare i valori int. Le espressioni regolari possono aiutare:</p>
<pre class="brush: js">var filterInt = function(value) {
if (/^(-|\+)?(\d+|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="Specifiche">Specifiche</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Specifica</th>
<th scope="col">Stato</th>
<th scope="col">Commento</th>
</tr>
<tr>
<td>{{SpecName('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Definizione iniziale.</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="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
<p>{{Compat("javascript.builtins.parseInt")}}</p>
<h2 id="Vedi_anche">Vedi anche</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>
|
