From da78a9e329e272dedb2400b79a3bdeebff387d47 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:17 -0500 Subject: initial commit --- .../reference/global_objects/parseint/index.html | 190 +++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 files/it/web/javascript/reference/global_objects/parseint/index.html (limited to 'files/it/web/javascript/reference/global_objects/parseint/index.html') diff --git a/files/it/web/javascript/reference/global_objects/parseint/index.html b/files/it/web/javascript/reference/global_objects/parseint/index.html new file mode 100644 index 0000000000..c6300b4b3e --- /dev/null +++ b/files/it/web/javascript/reference/global_objects/parseint/index.html @@ -0,0 +1,190 @@ +--- +title: parseInt() +slug: Web/JavaScript/Reference/Global_Objects/parseInt +translation_of: Web/JavaScript/Reference/Global_Objects/parseInt +--- +
{{jsSidebar("Objects")}}
+ +

La funzione parseInt() analizza un argomento stringa e restituisce un numero intero della radice specificata (la base nei sistemi numerici matematici).

+ +
{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}
+ + + +

Sintassi

+ +
parseInt(string, radix);
+ +

Parametri

+ +
+
string
+
Il valore da analizzare. Se l'argomento string non è una stringa, viene convertito in una stringa (utilizzando l'operazione astratta ToString). Gli spazi bianchi iniziali nell'argomento stringa vengono ignorati.
+
radix
+
Un numero intero compreso tra 2 e 36 che rappresenta la radice (la base nei sistemi numerici matematici) della stringa sopra menzionata.
+
+ +

Valore di ritorno

+ +

Un numero intero analizzato dalla stringa specificata. Se il primo carattere non può essere convertito in un numero, viene restituito {{jsxref("NaN")}}.

+ +

Descrizione

+ +

La funzione parseInt converte il suo primo argomento in una stringa, lo analizza e restituisce un numero intero o NaN. Se non è NaN, il valore restituito sarà l'intero che è il primo argomento preso come numero nella radice specificata (base). Ad esempio, una radice di 10 indica la conversione da un numero decimale, 8 ottali, 16 esadecimali e così via. Per le radici sopra 10, le lettere dell'alfabeto indicano numeri maggiori di 9. Ad esempio, per i numeri esadecimali (base 16), vengono utilizzate le lettere da A a F.

+ +

Se parseInt 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. parseInt tronca i numeri ai valori interi. Sono ammessi spazi iniziali e finali.

+ +

Poiché alcuni numeri includono il carattere e nella loro rappresentazione di stringa (ad esempio 6.022e23), l'uso di parseInt per troncare valori numerici produrrà risultati imprevisti se utilizzato su numeri molto grandi o molto piccoli. parseInt non dovrebbe essere usato come sostituto di {{jsxref("Math.floor()")}}.

+ +

Se radix è undefined o 0 (o assente), JavaScript assume quanto segue:

+ + + +

Se il primo carattere non può essere convertito in un numero, parseInt restituisce NaN.

+ +

Per scopi aritmetici, il valore NaN vnon è un numero in nessuna radice. È possibile chiamare la funzione {{jsxref("isNaN")}} per determinare se il risultato di parseInt è NaN. Se NaN viene passato alle operazioni aritmetiche, i risultati dell'operazione saranno anche NaN.

+ +

Per convertire il numero nella sua stringa letterale in una particolare radix, usa intValue.toString(radix).

+ +

Esempi

+ +

Usare parseInt

+ +

Tutti gli esempi seguenti restituiscono 15:

+ +
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);
+
+ +

I seguenti esempi restituiscono tutti NaN:

+ +
parseInt('Hello', 8); // Non è un numero
+parseInt('546', 2);   // Le cifre non sono valide per le rappresentazioni binarie
+
+ +

Tutti gli esempi seguenti restituiscono -15:

+ +
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);
+
+ +

Tutti gli esempi seguenti restituiscono 4:

+ +
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
+
+ +

L'esempio seguente restituisce 224:

+ +
parseInt('0e0', 16);
+
+ +

Interpretazioni ottali senza radix

+ +

Sebbene scoraggiato da ECMAScript 3 e proibito da ECMAScript 5, molte implementazioni interpretano una stringa numerica che inizia con uno 0 iniziale come ottale. Il seguente potrebbe avere un risultato ottale o potrebbe avere un risultato decimale. Specifica sempre una radice per evitare questo comportamento inaffidabile.

+ +
parseInt('0e0'); // 0
+parseInt('08'); // 0, '8' non è una cifra ottale.
+
+ +

ECMAScript 5 rimuove l'interpretazione ottale

+ +

La specifica ECMAScript 5 della funzione parseInt non consente più alle implementazioni di trattare le stringhe che iniziano con un carattere 0 come valori ottali. ECMAScript 5 afferma:

+ +

La funzione parseInt 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 0, si presume che sia 10 tranne quando il numero inizia con le coppie di caratteri 0x o 0X, nel qual caso si assume una radice di 16.

+ +

Ciò differisce da ECMAScript 3, che scoraggiava, ma consentiva l'interpretazione ottale.

+ +

Molte implementazioni non hanno adottato questo comportamento a partire dal 2013 e, poiché i browser più vecchi devono essere supportati, specificare sempre una radice.

+ +

Una funzione di analisi più rigorosa

+ +

A volte è utile avere un modo più rigoroso di analizzare i valori int. Le espressioni regolari possono aiutare:

+ +
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
+
+ +

Specifiche

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificaStatoCommento
{{SpecName('ES1')}}{{Spec2('ES1')}}Definizione iniziale.
{{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-parseint-string-radix', 'parseInt')}}{{Spec2('ESDraft')}} 
+ +

Compatibilità con i browser

+ + + +

{{Compat("javascript.builtins.parseInt")}}

+ +

Vedi anche

+ + -- cgit v1.2.3-54-g00ecf