Conversione di Tipi ECMAScript

Una delle caratteristiche più importanti di tutti i linguaggi di programmazione è la capacità di effettuare conversioni di tipo.

ECMAScript fornisce agli sviluppatori una vasta gamma di metodi di conversione di tipo semplici.

La maggior parte dei tipi ha metodi di conversione semplici, e ci sono anche alcuni metodi globali utilizzabili per conversioni più complesse. In ogni caso, nelle conversioni di tipo di ECMAScript, è un'operazione breve e diretta.

Converti in stringa

L'interessante degli oggetti primitivi Boolean, numeri e stringhe di ECMAScript è che sono oggetti pseudoinstanziali, il che significa che hanno effettivamente attributi e metodi.

Ad esempio, per ottenere la lunghezza di una stringa, puoi utilizzare il seguente codice:

var sColor = "red";
alert(sColor.length); // Output: "3"

Anche se "red" è una stringa primitiva, essa ha l'attributo length, utilizzato per memorizzare la dimensione della stringa.

In sintesi, i tre principali tipi primitivi Boolean, numeri e stringhe hanno il metodo toString(), che può convertire i loro valori in stringhe.

Suggerimento:Forse ti chiederai, 'Le stringhe hanno anche il metodo toString(), non è superfluo?' Sì, è così, ECMAScript definisce che tutti gli oggetti hanno il metodo toString(), sia che siano oggetti pseudoinstanziali o oggetti veri. Poiché il tipo String è un oggetto pseudoinstanziale, sicuramente ha il metodo toString().

Il metodo toString() del tipo Boolean outputta semplicemente "true" o "false", il risultato è determinato dal valore della variabile:

var bFound = false;
alert(bFound.toString());	// Output "false"

Il metodo toString() del tipo Number è particolarmente speciale, poiché ha due modelli, ovveroModello predefinitoeModello di baseUtilizzando il modello predefinito, il metodo toString() simply outputta il valore numerico corrispondente (sia esso un numero intero, un numero a virgola mobile o un numero in notazione scientifica), come mostrato di seguito:

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());	// Output "10"
alert(iNum2.toString());	// Output "10"

Nota:Nel modello predefinito, indipendentemente dal modo in cui è stato dichiarato il numero inizialmente, il metodo toString() del tipo Number restituisce sempre la rappresentazione decimale del numero. Pertanto, i numeri dichiarati in forma letterale ottale o esadecimale vengono outputti in forma decimale.

Utilizzando il modello di base del metodo toString() del tipo Number, è possibile usare diversiBaseOutput di numeri, ad esempio, la base binaria è 2, la base ottale è 8, la base esadecimale è 16.

BaseÈ semplicemente un'altra aggiunta per convertire in una base diversa, che è il parametro del metodo toString():

var iNum = 10;
alert(iNum.toString(2));	// Output "1010"
alert(iNum.toString(8));	// Output "12"
alert(iNum.toString(16));	// Output "A"

Nell'esempio precedente, il numero 10 è stato outputto in tre diverse forme, ovvero in forma binaria, ottale e esadecimale. L'HTML utilizza l'esadecimale per rappresentare ciascun colore, quindi questa funzionalità è molto utile quando si gestiscono numeri in HTML.

Nota:Chiamare toString(10) su un numero è equivalente a chiamare toString(), entrambi restituiscono la forma decimale del numero.

Vedere:

Vedere Manuale di riferimento di JavaScriptDettagli dettagliati relativi al metodo toString():

Conversione in numero

ECMAScript fornisce due metodi per convertire valori primitivi non numerici in numeri, ovvero parseInt() e parseFloat().

Come potete immaginare, il primo converte il valore in un intero, mentre il secondo lo converte in un numero a virgola mobile. Questi metodi funzionano correttamente solo quando vengono chiamati su oggetti di tipo String; per altri tipi, restituiscono NaN.

parseInt()

Prima di determinare se una stringa è un valore numerico, parseInt() e parseFloat() analizzano attentamente la stringa.

Il metodo parseInt() esamina prima il carattere alla posizione 0, per determinare se è un numero valido; se non lo è, il metodo restituisce NaN e non continua con altre operazioni. Tuttavia, se il carattere è valido, il metodo esamina il carattere alla posizione 1, eseguendo lo stesso test. Questo processo continua fino a che si incontra un carattere non valido, al quale punto parseInt() convertirà la stringa fino a quel carattere in un numero.

Ad esempio, se si desidera convertire la stringa "12345red" in un intero, il metodo parseInt() restituirà 12345, perché quando verifica il carattere r, interrompe il processo di verifica.

I numeri literali contenuti nella stringa vengono convertiti correttamente in numeri, ad esempio "0xA" viene convertito correttamente in 10. Tuttavia, la stringa "22.5" viene convertita in 22, perché il punto decimale è un carattere non valido per gli interi.

Ecco alcuni esempi:

var iNum1 = parseInt("12345red");	//ritorna 12345
var iNum1 = parseInt("0xA");	//ritorna 10
var iNum1 = parseInt("56.9");	//ritorna 56
var iNum1 = parseInt("red");	//ritorna NaN

Il metodo parseInt() ha anche un modello di base, che può convertire una stringa binaria, ottale, esadecimale o di qualsiasi altro sistema di numerazione in un intero. La base è specificata dal secondo parametro del metodo parseInt(), quindi per interpretare un valore esadecimale, è necessario chiamare il metodo parseInt() come segue:

var iNum1 = parseInt("AF", 16);	//ritorna 175

Certo, è possibile chiamare il metodo parseInt() in questo modo per binario, ottale, decimale (modalità predefinita) e altri sistemi di numerazione:

var iNum1 = parseInt("10", 2);	//ritorna 2
var iNum2 = parseInt("10", 8);	// restituisce 8
var iNum3 = parseInt("10", 10);	// restituisce 10

Se un numero decimale contiene un 0 iniziale, è meglio usare il基底 10 per evitare di ottenere un valore ottale per errore. Ad esempio:

var iNum1 = parseInt("010");	// restituisce 8
var iNum2 = parseInt("010", 8);	// restituisce 8
var iNum3 = parseInt("010", 10);	// restituisce 10

In questo segmento di codice, due righe di codice interpretano la stringa "010" come un numero. La prima riga considera la stringa come un valore ottale, interpretandola allo stesso modo della seconda riga (dichiarando il基底 come 8). L'ultima riga dichiara il基底 come 10, quindi iNum3 alla fine è uguale a 10.

Vedere

Vedere Manuale di riferimento di JavaScriptDi seguito sono riportati dettagli dettagliati sul metodo parseInt():parseInt().

parseFloat()

Il metodo parseFloat() ha un comportamento simile al metodo parseInt(), guardando ogni carattere a partire dalla posizione 0 fino a trovare il primo carattere non valido, e poi convertendo la stringa prima di quel carattere in un intero.

Tuttavia, per questo metodo, il primo punto decimale è un carattere valido. Se ci sono due punti decimali, il secondo punto decimale viene considerato invalido. parseFloat() convertirà i caratteri prima del punto decimale in numeri. Questo significa che la stringa "11.22.33" viene interpretata come 11.22.

Un altro aspetto diverso dell'uso del metodo parseFloat() è che la stringa deve essere rappresentata in forma decimale per il numero a virgola mobile, non in ottale o esadecimale. Questo metodo ignora i 0 iniziali, quindi il numero ottale 0102 viene interpretato come 102. Per il numero esadecimale 0xA, il metodo restituisce NaN, poiché x non è un carattere valido nei numeri a virgola mobile).Nota:Secondo i test, l'implementazione specifica del browser restituisce 0 invece di NaN).

Inoltre, il metodo parseFloat() non ha un modello di base.

Di seguito sono riportati alcuni esempi dell'uso del metodo parseFloat():

var fNum1 = parseFloat("12345red");	// restituisce 12345
var fNum2 = parseFloat("0xA");	// restituisce NaN
var fNum3 = parseFloat("11.2");	// restituisce 11.2
var fNum4 = parseFloat("11.22.33");	// restituisce 11.22
var fNum5 = parseFloat("0102"); // restituisce 102
var fNum1 = parseFloat("red"); // restituisce NaN

Prova tu stesso

Vedere

Vedere Manuale di riferimento di JavaScriptEcco i dettagli forniti sulla funzione parseFloat():parseFloat().

Conversione forzata

Puoi anche usareConversione forzata (type casting)per gestire il tipo di un valore da convertire. L'uso delle conversioni forzate permette di accedere a valori specifici, anche se sono di un altro tipo.

Nota dell'autore:Il termine "cast" significa "scoccare" e si adatta perfettamente al concetto di "conversione forzata".

Ci sono 3 tipi di conversioni forzate disponibili in ECMAScript:

  • Boolean(value) - trasforma il valore dato in un tipo Booleano;
  • Number(value) - trasforma il valore dato in un numero (può essere un intero o un numero a virgola mobile);
  • String(value) - trasforma il valore dato in una stringa;

Usando uno di questi tre funzioni per convertire un valore crea un nuovo valore che contiene il valore originale convertito. Questo può causare conseguenze impreviste.

La funzione Boolean()

Quando il valore da convertire è una stringa con almeno un carattere, un numero non zero o un oggetto, la funzione Boolean() restituisce true. Se il valore è una stringa vuota, il numero zero, undefined o null, restituisce false.

Puoi testare la conversione forzata di tipo Boolean con il seguente codice:

var b1 = Boolean(""); //false - stringa vuota
var b2 = Boolean("hello"); //true - stringa non vuota
var b1 = Boolean(50); //true - numero non zero
var b1 = Boolean(null); //false - null
var b1 = Boolean(0); //false - zero
var b1 = Boolean(new object()); //true - oggetto

La funzione Number()

La funzione Number() di tipo costruttivo ha un comportamento simile ai metodi parseInt() e parseFloat(), ma trasforma l'intero valore, non solo una parte di esso.

Ricordate, i metodi parseInt() e parseFloat() trasformano solo la stringa prima del primo carattere non valido, quindi "1.2.3" viene trasformato rispettivamente in "1" e "1.2".

Utilizzando Number(), "1.2.3" restituirà NaN, poiché il valore di stringa intero non può essere convertito in numero. Se il valore di stringa può essere convertito integralmente, Number() determinerà se chiamare il metodo parseInt() o parseFloat().

La tabella seguente spiega ciò che accade quando si chiama il metodo Number() con valori diversi:

Uso Risultato
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

Funzione String()

L'ultimo metodo di conversione di tipo forzata String() è il più semplice, poiché può convertire qualsiasi valore in stringa.

Per eseguire questa conversione di tipo forzata, è sufficiente chiamare il metodo toString() del valore passato come parametro, ovvero convertire 12 in "12", convertire true in "true", convertire false in "false" e così via.

L'unica differenza tra la conversione di tipo forzata in stringa e la chiamata al metodo toString() è che la conversione di tipo forzata di valori null e undefined può generare una stringa senza generare un errore:

var s1 = String(null);	// "null"
var oNull = null;
var s2 = oNull.toString();	// verrà generato un errore

Quando si gestisce un linguaggio di tipo debole come ECMAScript, la conversione di tipo forzata è molto utile, ma deve essere assicurato che l'uso del valore sia corretto.