Attenzione alla coercizione del tipo: questa funzionalità avanzata può essere la causa di bug sottili, quindi assicurati di sapere come funziona.

La digitazione dinamica di JavaScript significa che il tuo codice può essere un po' più semplice, ma è comunque possibile commettere errori. Per evitarli, è utile sapere come JavaScript risolve i valori con tipi diversi, per confrontarli.

Comprendere la conversione dei tipi e la coercizione in JavaScript è fondamentale per scrivere programmi affidabili ed efficienti. Ogni concetto ha casi d'uso specifici e best practice che possono influenzare il comportamento del tuo codice.

Perché la conversione del tipo e la coercizione avvengono in JavaScript?

Il linguaggio Javascript è tipizzato dinamicamente. Ciò significa che, a differenza dei linguaggi tipizzati staticamente, JavaScript non richiede di definire in modo esplicito il tipo di dati di una variabile prima di utilizzarla. Invece, JavaScript determina il tipo in fase di esecuzione in base al valore della variabile.

instagram viewer

Poiché i tipi di dati non vengono dichiarati in modo esplicito fino al runtime, quando si eseguono operazioni che richiedono dati diversi tipi, JavaScript controlla automaticamente la loro compatibilità tra loro per l'operazione che si desidera eseguire. Se sono compatibili tra loro, l'operazione procede normalmente.

Tuttavia, supponiamo che siano incompatibili con l'operazione, ad esempio tentando di aggiungere una stringa e un numero. In tali casi, JavaScript "costringe" automaticamente uno dei tipi ad adattarsi all'altro per garantire che l'operazione abbia successo invece di generare un errore. Questo processo è noto come coercizione di tipo o coercizione implicita.

Tipo Coercizione

La coercizione del tipo è la conversione automatica di un valore da un tipo di dati a un altro, eseguita da JavaScript durante l'esecuzione di un programma per garantire che un'operazione venga eseguita correttamente.

Ma non tutti i tipi di dati possono essere forzati. Stringa, numero e booleano sono gli unici Tipi di dati JavaScript che la lingua costringerà in un tipo diverso. Quando provi a eseguire un'operazione incompatibile con tipi di dati che JavaScript non può forzare, genererà un errore.

JavaScript forza i tipi in base al tipo di operazione e all'operatore utilizzato nell'operazione.

Coercizione con l'operatore “+”.

In JavaScript, il "+L'operatore ” ha due comportamenti diversi a seconda dei tipi dei suoi operandi. Può eseguire sia l'addizione numerica che la concatenazione di stringhe. Questo può portare alla coercizione del tipo quando uno degli operandi non è del tipo previsto.

Se entrambi gli operandi sono numeri, il "+” l'operatore esegue l'addizione:

permettere numero1 = 42;
permettere numero2 = 10;
permettere somma = num1 + num2; // Aggiunta
consolare.log (somma); // 52

Se entrambi gli operandi sono stringhe, il "+L'operatore " esegue la concatenazione di stringhe:

permettere str1 = "Ciao";
permettere str2 = "mondo";
permettere risultato = str1 + " " +str2; // Concatenazione di stringhe
consolare.log (risultato); // "Ciao mondo"

Tuttavia, se uno degli operandi non è una stringa, JavaScript lo forza implicitamente in una stringa prima di eseguire la concatenazione:

// Numero e stringa
permettere numero = 42;
permettere stra = "Ciao";
// num viene forzato in una stringa e quindi concatenato
permettere risultato_1 = num + str;
consolare.log (risultato_1); // "42Ciao"


// Stringa e booleano
permettere bool = VERO;
// bool viene forzato in una stringa e quindi concatenato
permettere risultato_2 = bool + str;
consolare.log (risultato_2); // "veroCiao"

Coercizione con l'operatore “-”.

In JavaScript, il "-L'operatore ” viene utilizzato principalmente per le operazioni di sottrazione. Quando uno o entrambi gli operandi in un'operazione che coinvolge il "-” l'operatore non è un numero, JavaScript tenterà di trasformarlo in un numero.

Quando entrambi gli operandi sono numeri, JavaScript esegue la sottrazione. Esegue anche la sottrazione quando uno o entrambi gli operandi sono stringhe che rappresentano un numero:

cost numero1 = 10;
cost numero2 = 20;
cost risultato_1 = num2 - num1; // Sottrazione
consolare.log (risultato_1); // 10
cost strNum = "10";
cost strNum2 = "20";
cost risultato = strNum2 - strNum; // Digita coercizione ai numeri, quindi sottrazione
consolare.log (risultato_1); // 10

Quando nessuno degli operandi è un numero o una stringa che rappresenta un numero, JavaScript proverà a forzare il tipo di dati al suo equivalente numerico. Se il tipo di dati non ha un equivalente numerico, l'operazione restituirà NaN (Non un numero):

// true viene forzato a 1, false viene forzato a 0
cost boolNum = VERO;
cost boolNum2 = falso;
cost risultato_1 = boolNum - boolNum2;
consolare.log (risultato_1); // 1
// gli array vuoti vengono costretti a 0
cost numeroarr = [];
cost arrNum2 = [];
cost risultato_2 = arrNum - arrNum2;
consolare.log (risultato_2); // 0
// gli oggetti vuoti vengono costretti a NaN
cost oggettoNum = {};
cost risultato_3 = arrNum - objNum;
consolare.log (risultato_3); // 0 - NaN = NaN

In questo esempio, JavaScript forza i valori booleani VERO E falso ai loro valori numerici equivalenti, 1 E 0, rispettivamente. Gli array vuoti sono costretti a 0, e gli oggetti vuoti sono costretti a NaN.

Coercizione con gli operatori di uguaglianza (==)/()

In JavaScript, gli operatori di uguaglianza (== E ) confrontare i valori per l'uguaglianza. Tuttavia, si comportano in modo diverso a causa della coercizione del tipo.

IL "==L'operatore "(uguaglianza libera) esegue la coercizione del tipo, nel senso che tenta di convertire gli operandi nello stesso tipo prima del confronto:

"10" == 10; // VERO

In questo esempio, JavaScript costringe la stringa "10" al numero 10, quindi l'espressione restituisce VERO.

Comunque, il "L'operatore ” (uguaglianza rigorosa) non esegue la coercizione del tipo. Richiede che il valore e il tipo siano gli stessi per restituire il confronto VERO:

"10"10; // falso

In questo esempio, il confronto ritorna falso perché gli operandi sono di tipi diversi (stringa e numero).

In genere dovresti usare il (uguaglianza rigorosa) in JavaScript per evitare comportamenti di coercizione del tipo imprevisti.

La coercizione del tipo o la conversione implicita può portare a un comportamento imprevisto a causa della sua natura automatica. Nei casi in cui è necessario convertire i tipi, è consigliabile convertire esplicitamente i tipi. Il processo di conversione esplicita dei tipi è noto come conversione del tipo. Viene anche definito casting di tipo e conversione di tipo esplicita.

Tipo Conversione

La conversione del tipo, nota anche come casting del tipo, è il processo esplicito di conversione di un valore da un tipo di dati a un altro in JavaScript utilizzando funzioni integrate come Numero(), Corda(), booleano(), analisiInt(), E parseFloat().

È possibile eseguire la conversione del tipo passando il valore che si desidera convertire nelle funzioni di conversione integrate come argomento. Queste funzioni quindi convertono il tuo valore nel tipo desiderato.

Ecco un esempio usando il Numero() funzione:

cost numStr = "123";
cost numero = Numero(numStr); // Converte una stringa in un numero
consolare.log (numero); // 123

Passando una stringa che è un numero valido come argomento a Numero() funzione restituirà un numero. Il passaggio di una stringa che è un numero non valido restituirà NaN.

Ecco un esempio usando il Corda() funzione:

cost bool = VERO;
cost str2 = Corda(booleano); // Converte un valore booleano in una stringa
consolare.log (str2); // "VERO"

Passando qualsiasi tipo di dati in eccetto un simbolo in Corda() funzione convertirà il tipo di dati in una stringa.

Ecco un esempio usando il booleano() funzione:

// Converti una stringa in un valore booleano (truthy: true, falsy: false)
cost stra = "Ciao";
cost bool2 = Booleano(str);
consolare.log (bool2); // VERO

Passare valori veritieri al booleano() la funzione restituisce il valore booleano "vero" mentre passando i valori falsi restituisce il valore booleano "falso".

Ecco un esempio usando il AnalizzaInt() E ParseFloat() funzione:

// Converte una stringa in un numero intero
cost numStr = "123.00";
cost numero1 = parseInt(numStr);
consolare.log (num1); // 123
// Converte una stringa in un numero a virgola mobile
cost floatStr = "3.14";
cost numero2 = parseFloat(floatStr);
consolare.log (num2); // 3.14

IL analisiInt() La funzione analizza un argomento stringa e restituisce un numero intero. IL parseFloat() La funzione converte una stringa in un numero a virgola mobile.

Sfruttando il tipo di coercizione e conversione

Comprendendo la coercizione e la conversione del tipo, puoi prendere decisioni informate su quando e come sfruttarle efficacemente nel tuo codice. È importante trovare il giusto equilibrio, usando la coercizione del tipo in modo giudizioso per un codice conciso e conveniente e affidandosi alla conversione del tipo esplicita per conversioni di tipo intenzionali e prevedibili.