JavaScript ha 2 funzioni integrate per convertire le stringhe in numeri: parseFloat() e parseInt() .
parseFloat() accetta come argomento una stringa da convertire in un tipo numerico e restituisce un numero float. Il numero deve essere all'inizio della riga. Se ci sono altri caratteri dopo il numero nella stringa, vengono tagliati. La parte frazionaria del numero deve essere scritta attraverso un punto (la virgola non viene percepita come separatore). Nel caso in cui parseFloat() non possa convertire la stringa, restituisce NaN.
Inoltre, la funzione può elaborare "il numero n moltiplicato per 10 alla potenza di x", che di solito viene scritto in programmazione tramite la lettera E, ad esempio: 0.5E6 o 0.5E+6. Il grado può anche essere negativo: 0.5E-6, che equivale a 0.5*10^-6 o 0.5/1000000.
ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003
La funzione parseInt(string[, radix]) accetta una stringa come primo argomento, la analizza e restituisce un numero intero (tipo intero). La funzione tenta di analizzare il sistema numerico in cui è scritto il numero nella stringa sorgente (ad esempio, decimale, ottale o esadecimale, ma non solo). Inoltre, il sistema numerico può essere specificato esplicitamente passandolo come secondo parametro a radix. Il parametro radix può assumere qualsiasi numero compreso tra 2 e 36 (i sistemi superiori a 10 utilizzano l'alfabeto inglese, dalla A alla Z).
Numeri come 1.5e6 non vengono gestiti allo stesso modo di parseFloat() .
Si prega di leggere gli esempi seguenti per non incorrere nelle insidie nascoste nel lavoro della funzione parseInt().
ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 in ottale è 56 in decimale) parseInt(""070"") // 56 (IMPORTANTE!!! zero prima farà sì che la funzione analizzi la stringa come un numero ottale ) parseInt(" "88"",8) // NaN (non esiste la cifra 8 nel sistema ottale) parseInt(""a1"") // NaN (IMPORTANTE!!! La funzione predefinita non tratta il numero come esadecimale a meno che tu non lo aggiunga all'inizio stringhe 0x) parseInt(""a1"",16) // 161 (il sistema numerico è esplicitamente specificato qui) parseInt(""0xa1"") // 161 (formato esadecimale corretto, il secondo parametro può essere omesso) parseInt( ""099"") // 0 (IMPORTANTE!!! Il numero è trattato come ottale ma contiene caratteri non validi) parseInt(""0.5e6"") // 0 (IMPORTANTE!!! non non funziona come parseFloat) parseInt("" ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) // -255
Se stai elaborando dati da un campo di testo inserito dall'utente, usa sempre parseInt() insieme al secondo parametro radix, questo proteggerà il tuo codice da risultati imprevisti.
Non importa quale tipo di variabile viene utilizzato nell'espressione. Se l'espressione è matematica, tutte le sue variabili saranno automaticamente interpretate come numeriche. Se le stringhe vengono elaborate, tutti i "partecipanti" dell'espressione vengono trattati come stringhe. Tuttavia, il compito di convertire JavaScript "stringa in numero" esiste in un contesto molto più ampio.
L'arsenale di metodi per convertire stringhe in numeri non è eccezionale, ma sufficiente in tutti i casi semplici. Qui JavaScript (soprattutto per i principianti) è la via dal semplice al complesso con esempi pratici.
Sarai interessato:
L'esempio descrive quattro stringhe diverse. Nel primo blocco di output, il tipo di ogni variabile nella funzione typeof è definito come stringa. Ogni stringa viene quindi convertita molto semplicemente in un numero. Nel secondo blocco di output, puoi vedere i cambiamenti nelle variabili dopo la conversione, il loro tipo è diventato un numero. L'esempio di conversione JavaScript parseFloat è particolarmente rivelatore: era "12e+3", ora è "12000".
Le modifiche durante la conversione di una stringa in un numero possono essere significative! Ma contano solo i primi caratteri: devono essere numerici. Se non ci sono caratteri numerici, il risultato sarà NaN.
La conversione inversa di una stringa che "diventa" un numero non è sempre la stessa stringa. Questo momento può essere utilizzato per verificare la correttezza dell'inserimento delle informazioni numeriche.
Ciao cari lettori. Oggi scriverò come viene convertito in javascript stringa al numero. Questo viene fatto usando la funzione Numero, ora ne mostrerò l'uso con un esempio.
Suggerisco anche di guardare la versione video di questo articolo:
Come sai, javascript ha un tipo di dati numerico e stringa. Proviamo a creare due variabili in cui memorizziamo i numeri e poi mostriamo il risultato sullo schermo.
Vara = 5; variabile b = 12; documento.scrivi(a+b);
Quale sarà il risultato? 17, che è quello che ci ha mostrato il browser. Quindi, sono dati numerici, quindi il browser li ha sommati correttamente. E ora creiamo altre due variabili, nelle quali mettiamo gli stessi valori, ma tra virgolette. Lascia che ti ricordi che tutte le stringhe in javascript sono scritte tra virgolette.
Var c = "5"; vard = "12"; documento.write("
" + c + d);
Ora il browser considera i nostri dati come stringhe e se li aggiungiamo, allora verranno semplicemente aggiunte due stringhe e otterremo 512, che non è il risultato corretto se i numeri sono stati sommati, ma è corretto se mettiamo insieme due stringhe.
Qui è tutto semplice, creiamo le prossime due variabili, in cui scriveremo lo stesso valore che viene impostato sulle variabili c e d , ma passandole attraverso il metodo Number:
Vare = Numero(c); var f = Numero(d); documento.write(e+f);
Se ora provi a visualizzare il risultato di questa addizione sullo schermo, verrà visualizzato 17. Questo perché il nostro metodo ha completato con successo e ha convertito la stringa in un numero. Voglio notare che se scrivi così:
Documento.write("
"+e+f);
Quindi 512 verrà visualizzato sullo schermo, perché quando si aggiungono stringhe e numeri SEMPRE il risultato viene convertito in una stringa. Se vuoi aggiungere un'interruzione di riga e mantenere comunque il risultato corretto, puoi scrivere tutto su due righe o una riga in questo modo:
Documento.write("
"+(e+f));
Se prendi i numeri tra parentesi, non verranno convertiti in stringhe e salveranno correttamente le loro proprietà. Ecco un articolo così breve che ho oggi. Spero che javascript sia diventato un po' più chiaro per te.
IL analisiInt() La funzione analizza un argomento stringa e restituisce un numero intero della radice specificata (la base nei sistemi numerici matematici).
L'origine per questo esempio interattivo è archiviata in un repository GitHub. Se desideri contribuire al progetto di esempi interattivi, clona https://github.com/mdn/interactive-examples e inviaci una richiesta pull.
Un numero intero analizzato dalla stringa data.
Se la radice è minore di 11 e il primo carattere diverso da spazi bianchi non può essere convertito in un numero, viene restituito NaN.
La funzione parseInt converte il suo primo argomento in una stringa, analizza tale stringa, quindi 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. (Ad esempio, una radice di 10 converte da un numero decimale, 8 converte da ottale, 16 da esadecimale e così via.)
Per radici superiori a 10 , le lettere dell'alfabeto inglese indicano numeri maggiori di 9 . Ad esempio, per i numeri esadecimali (base 16), vengono utilizzati 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 in valori interi. Gli spazi iniziali e finali sono consentiti.
Poiché alcuni numeri utilizzano il carattere e nella loro rappresentazione di stringa (ad es. 6.022e23 per 6,022 × 10 23), l'utilizzo di parseInt per troncare i numeri produrrà risultati imprevisti se utilizzato su numeri molto grandi o molto piccoli. parseInt dovrebbe non essere utilizzato come sostituto di Math.floor() .
parseInt comprende esattamente due segni: + per positivo e - per negativo (a partire da ECMAScript 1). Viene eseguito come passaggio iniziale nell'analisi dopo la rimozione degli spazi bianchi. se non vengono trovati segni, l'algoritmo passa al passo successivo; in caso contrario, rimuove il segno ed esegue l'analisi numerica sul resto della stringa.
Se radix è undefined , 0 o non specificato, JavaScript presuppone quanto segue:
Se il primo carattere non può essere convertito in un numero, parseInt restituisce NaN a meno che la radice non sia maggiore di 10 .
Per scopi aritmetici, il valore NaN non è un numero in nessuna radice. Puoi chiama la funzione isNaN per determinare se il risultato di parseInt è NaN . Se NaN viene passato alle operazioni aritmetiche, anche il risultato dell'operazione sarà NaN .
Per convertire un numero nella sua stringa letterale in una particolare radice, usa thatNumber .toString(radix) .
I seguenti esempi restituiscono tutti 15:
ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // ma `parseInt(015, 10)` return 13 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("Ciao", 8) // Non è affatto un numero parseInt("546", 2) // Le cifre diverse da 0 o 1 non sono valide per la radice binaria
I seguenti esempi restituiscono tutti -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)
I seguenti esempi restituiscono tutti 4:
ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Un numero molto grande diventa 4 parseInt(0.000000000000434, 10) // Un numero molto piccolo diventa 4
L'esempio seguente restituisce 224:
ParseInt("0e0", 16) parseInt("123_456") // 123
Sebbene scoraggiate da ECMAScript 3 e vietate da ECMAScript 5, molte implementazioni interpretano una stringa numerica che inizia con uno 0 iniziale come ottale. Quanto segue può avere un risultato ottale o può avere un risultato decimale. Specificare sempre una radice per evitare questo comportamento inaffidabile.
ParseInt("0e0") // 0 parseInt("08") // 0, perché "8" non è una cifra 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 iniziale nella stringa viene ignorato. Se radix è undefined 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 meno recenti devono essere supportati, specificare sempre una radice.
A volte è utile avere un modo più rigoroso per analizzare i numeri interi.
Le espressioni regolari possono aiutare:
Funzione filterInt(value) ( if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( 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
| Specifica | Stato | Commento |
|---|---|---|
| ECMAScript 1a edizione (ECMA-262) | standard | definizione iniziale. |
| ECMAScript 5.1 (ECMA-262) |
standard | |
| ECMAScript 2015 (6a edizione, ECMA-262) La definizione di "parseInt" in quella specifica. |
standard | |
| ECMAScript ultima bozza (ECMA-262) La definizione di "parseInt" in quella specifica. |
Bozza |
La tabella di compatibilità in questa pagina è generata da dati strutturati. Se desideri contribuire ai dati, controlla https://github.com/mdn/browser-compat-data e inviaci una richiesta pull.
Aggiorna i dati di compatibilità su GitHub
| Scrivania | Mobile | server | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Cromo | bordo | Firefox | Internet Explorer | musica lirica | safari | visualizzazione Web Android | Chrome per Android | Firefox per Android | Opera per Android | Safari su iOS | Samsung Internet | Node.js | |
| parseInt | Chrome Supporto completo 1 | Edge Supporto completo 12 | Firefox Pieno supporto 1 | IE Pieno supporto 3 | Opera Pieno supporto Sì | Safari Pieno supporto Sì | WebView Android Supporto completo 1 | Chrome Android Supporto completo 18 | Firefox Android Supporto completo 4 | Safari iOS Supporto completo Sì | Samsung Internet Android Supporto completo 1.0 | nodejs Supporto completo Sì | |
| Le stringhe con lo zero iniziale di Parses sono decimali, non ottali | Chrome Supporto completo 23 | Edge Supporto completo 12 | Supporto completo per Firefox 21 | IE Pieno supporto 9 | Opera Pieno supporto Sì | Safari Pieno supporto 6 | WebView Android Supporto completo 4.4 | Chrome Android Supporto completo 25 | Firefox Android Supporto completo 21 | Opera Android Pieno supporto Sì | Safari iOS Supporto completo 6 | Samsung Internet Android Supporto completo Sì | nodejs Supporto completo Sì |
JavaScript è un linguaggio con tipizzazione dinamica dei dati. Ciò significa che valori di tipi diversi possono essere scritti nella stessa variabile, mentre il tipo della variabile stessa cambierà. Questo comportamento spesso ti consente di dimenticare il diverso comportamento delle variabili con tipi diversi, ma devi comunque ricordare questa funzione. Mostriamolo nel seguente esempio.
console.log(somma(1, 2)); // 3 (qui va tutto bene) console.log(sum(1, "2")); // 12 (e non così tanto qui)
Come puoi vedere dall'esempio, la funzione somma si comporta in modo errato se almeno uno dei suoi argomenti non è un numero. Il fatto è che quando "aggiungi" un numero a una stringa, il numero viene convertito in una stringa e viene concatenato (incollato) con il secondo operando.
Per evitare tali complicazioni, è possibile scoprire il tipo di una variabile durante l'esecuzione dello script e correggerne il comportamento, oppure monitorare attentamente i tipi di variabili.
Questo operatore unario accetta qualsiasi valore come operando e ne restituisce il tipo in una variabile stringa.
JavaScript ha i seguenti tipi di dati:
| // 1.) oggetto console.log (typeof ( ) ); // oggetto var p = ( x: 1 , y: 3 ); console.log (tipo di p) ; // oggetto // 2.) funzione function sayHello() ( console.log ("Ciao!" ) ; ) console.log (typeof sayHello) ; // funzione // 3.) stringa console.log (tipo di "JavaScript" ); // string // 4.) numero console.log (typeof 3.1415 ); // numero // 5.) boolean console.log (typeof true ); // boolean // 6.) undefined var notExistsOne; console.log (tipo di notExistsOne) ; // undefined console.log (typeof notExistsTwo) ; // non definito |
// 1.) oggetto console.log(typeof()); // oggetto var p = (x: 1, y: 3); console.log(typeofp); // oggetto // 2.) function function sayHello() ( console.log("Hello!"); ) console.log(typeof sayHello); // funzione // 3.) string console.log(typeof "JavaScript"); // stringa // 4.) numero console.log(typeof 3.1415); // numero // 5.) boolean console.log(typeof true); // boolean // 6.) undefined var notExistsOne; console.log(typeof notExistsOne); // undefined console.log(typeof notExistsTwo); // non definito
notare che non definitoè anche un tipo di dati costituito da un singolo valore.
Il casting di tipo nella programmazione è la conversione di un valore di una variabile di un tipo in un valore di un altro tipo.
Spesso questa trasformazione avviene senza il controllo del programmatore. Questo può essere visto nell'esempio con la funzione somma. Una modifica di tipo si verifica quando il risultato dell'esecuzione di un'operazione su una variabile del tipo originale non è chiaro. Ad esempio, è impossibile dire esattamente cosa risulterà dall'addizione di una stringa con un numero, ma l'operazione di addizione di due numeri è ovvia, ed in questo caso è logico accostare il numero alla stringa.
A volte il programmatore stesso può cambiare il tipo di una variabile applicandovi alcune operazioni. Ad esempio, le operazioni di incremento o decremento su una stringa la convertiranno in un numero.
var c = "non-un-numero"; ++c; console.log(tipo di c); // NaN
Vale la pena notare che non è necessario ricorrere a questo metodo per convertire una stringa in un numero a causa della sua scarsa leggibilità e non ovvietà. Ci sono funzioni integrate in js per questa attività. parseInt E parseFloat. Prendono come primo argomento una stringa da convertire in un numero e come secondo argomento facoltativo prendono la base del sistema numerico che contiene il numero nella stringa passata come primo argomento. Se il secondo argomento non è specificato, si considererà che la stringa contiene un numero nel sistema numerico decimale.
Funzione parseInt viene utilizzato per convertire una stringa in un numero intero e la funzione parseFloat convertire in frazionario.
| var a = parseInt("10") ; console.log ([ "a = " , a, "; typeof a:" , typeof a] .join (" " ) ) ; // a = 10 ; tipo di a: numero var pi = parseInt("3.1415" ) ; console.log("pi = " + pi greco) ; // pi = 3 pi = parseFloat("3.1415" ); console.log("pi = " + pi greco) ; // pi greco = 3,1415 |
var a = parseInt("10"); console.log(["a = ", a, "; typeof a:", typeof a].join(" ")); // a = 10 ; tipo di a: numero var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3.1415"); console.log("pi = " + pi); // pi greco = 3,1415
Si noti che la stringa può contenere qualsiasi valore numerico letterale, inclusi esadecimale, ottale o esponenziale.
| a = parseInt("010") ; console.log("a = " + a) ; // a = 8 a = parseInt("0xAA" ) ; console.log("a = " + a) ; // a = 170 a = parseFloat("1e-10" ); console.log("a = " + a) ; // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001) |
a = analizzaInt("010"); console.log("a = " + a); // a = 8 a = parseInt("0xAA"); console.log("a = " + a); // a = 170 a = parseFloat("1e-10"); console.log("a = " + a); // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001)
Come secondo parametro delle funzioni parseInt E parseFloatè possibile specificare la base del sistema numerico.
| a = parseInt("10" , 8 ) ; console.log("a = " + a) ; // a = 8 a = parseInt("010" , 10 ) ; console.log("a = " + a) ; // a = 10 a = parseInt("ff" , 16 ) ; console.log("a = " + a) ; // a = 255 |
a = parseInt("10", 8); console.log("a = " + a); // a = 8 a = parseInt("010", 10); console.log("a = " + a); // a = 10 a = parseInt("ff", 16); console.log("a = " + a); // a = 255
Se il valore è nella stringa, quali funzioni parseInt E parseFloat prendi come primo parametro, non è un letterale numerico, quindi il risultato dell'esecuzione di queste funzioni sarà il valore NaN.
| a = parseInt("non è un numero" ); console.log("a = " + a) ; // a = NaN a = parseFloat("non è un numero" ) ; console.log("a = " + a) ; // a = NaN |
a = parseInt("non è un numero"); console.log("a = " + a); // a = NaN a = parseFloat("non è un numero"); console.log("a = " + a); // a = NaN
In JavaScript, un valore di qualsiasi tipo può essere convertito in una stringa. Si è già detto sopra che quando una stringa viene concatenata con un numero, il numero viene ridotto a una stringa, e solo allora avviene la concatenazione. Ciò accadrà con qualsiasi tipo di valore.
| var str = "Oggetto: " + ( ) ; log della console (str) ; // Oggetto: str = "Array: " + [ 1 , 2 , 3 ] ; log della console (str) ; // Array: 1,2,3 function sum(a, b) ( return a + b; ) str = "Function: " + sum; log della console (str) ; /* Funzione: funzione sum(a, b) ( return a + b; ) */ |
var str = "Oggetto: " + (); log della console(str); // Oggetto: str = "Array: " + ; log della console(str); // Array: 1,2,3 function sum(a, b) ( return a + b; ) str = "Function: " + sum; log della console(str); /* Funzione: funzione sum(a, b) ( return a + b; ) */
Infatti, quando si esegue il cast di un oggetto su una stringa, il metodo viene chiamato implicitamente accordare, che può anche essere chiamato esplicitamente.
| var p = ( x: 2 , y: 4 ) , str; str = p.toString(); console.log (tipo di str) ; // stringa console.log (str) ; // str = [1, 2, 3] .toString (); console.log (tipo di str) ; // stringa console.log (str) ; // 1,2,3 |
var p = (x: 2, y: 4), str; str = p.toString(); console.log(tipodistr); // stringa console.log(str); // str = .toString(); console.log(tipodistr); // stringa console.log(str); // 1,2,3
La conversione in un numero si verifica quando si eseguono operazioni matematiche e quando si esegue un'operazione di confronto con casting di tipo (==, !=), mentre il valore falso E matrice vuota vengono convertiti nel valore 0 di tipo numero.
var a = vero + vero + vero; // 1 + 1 + 1 console.log(a); // 3
Un array, un oggetto e una funzione non vuoti vengono convertiti in una stringa quando utilizzati nelle espressioni aritmetiche.
| var arr = [1, 2, 3]; console.log (arr + 4 ); // 1,2,34 funzione sum(a, b) ( return a + b; ) console.log (sum + 5 ) ; // funzione sum(a, b)(return a + b;)5 |
var arr = ; console.log(arr + 4); // 1,2,34 funzione sum(a, b)(return a + b;) console.log(sum + 5); // funzione sum(a, b)(return a + b;)5
Come puoi vedere, la conversione di tipo implicita in js è tutt'altro che ovvia, quindi dovresti evitarla utilizzando funzioni per la conversione di tipo esplicita, come parseInt, parseFloat E accordare.
È tutto. Come sempre, buona fortuna a te!
