Comprender la conversión de tipos y la coerción en JavaScript

La escritura dinámica de JavaScript significa que su código puede ser un poco más simple, pero aún es posible cometer errores. Para evitarlos, es útil saber cómo resuelve JavaScript los valores con diferentes tipos, para compararlos.

Comprender la conversión de tipos y la coerción en JavaScript es crucial para escribir programas confiables y eficientes. Cada concepto tiene casos de uso específicos y mejores prácticas que pueden afectar el comportamiento de su código.

¿Por qué ocurre la conversión de tipo y la coerción en JavaScript?

El lenguaje JavaScript se escribe dinámicamente. Esto significa que, a diferencia de los lenguajes tipificados estáticamente, JavaScript no requiere que defina explícitamente el tipo de datos de una variable antes de usarla. En su lugar, JavaScript determina el tipo en tiempo de ejecución según el valor de la variable.

Dado que los tipos de datos no se declaran explícitamente hasta el tiempo de ejecución, cuando realiza operaciones que requieren datos diferentes tipos, JavaScript comprueba automáticamente su compatibilidad entre sí para la operación que desea realizar. Si son compatibles entre sí, la operación procede con normalidad.

Sin embargo, suponga que son incompatibles con la operación; por ejemplo, intentar sumar una cadena y un número. En tales casos, JavaScript "obliga" automáticamente a uno de los tipos a adaptarse al otro para garantizar que la operación sea exitosa en lugar de arrojar un error. Este proceso se conoce como coerción de tipo o coerción implícita.

Tipo Coerción

La coerción de tipos es la conversión automática de un valor de un tipo de datos a otro, realizada por JavaScript durante la ejecución de un programa para garantizar que una operación se ejecute correctamente.

Pero no todos los tipos de datos pueden ser forzados. Cadena, número y booleano son los únicos Tipos de datos de JavaScript que el lenguaje obligará a un tipo diferente. Cuando intenta realizar una operación incompatible con tipos de datos que JavaScript no puede coaccionar, arrojará un error.

JavaScript obliga a los tipos según el tipo de operación y el operador que usa en la operación.

Coerción con el operador “+”

En JavaScript, el “+El operador ” tiene dos comportamientos diferentes dependiendo de los tipos de sus operandos. Puede realizar sumas numéricas y concatenaciones de cadenas. Esto puede conducir a la conversión de tipos cuando uno de los operandos no es del tipo esperado.

Si ambos operandos son números, el “+El operador ” realiza la suma:

dejar numero1 = 42;
dejar numero2 = 10;
dejar suma = num1 + num2; // Suma
consola.log (suma); // 52

Si ambos operandos son cadenas, el “+El operador ” realiza la concatenación de cadenas:

dejar str1 = "Hola";
dejar str2 = "mundo";
dejar resultado = str1 + " " + str2; // concatenación de cadenas
consola.log (resultado); // "Hola Mundo"

Sin embargo, si uno de los operandos no es una cadena, JavaScript lo convertirá implícitamente en una cadena antes de realizar la concatenación:

// Número y Cadena
dejar número = 42;
dejar cadena = "Hola";
// num se convierte en una cadena y luego se concatena
dejar resultado_1 = num + str;
consola.log (resultado_1); // "42Hola"
// Cadena y Booleano
dejar bool = verdadero;
// bool se coacciona a una cadena y luego se concatena
dejar resultado_2 = bool + cadena;
consola.log (resultado_2); // "verdaderoHola"

Coerción con el operador “-”

En JavaScript, el “-El operador ” se utiliza principalmente para operaciones de resta. Cuando uno o ambos operandos en una operación que involucra el “-El operador no es un número, JavaScript intentará convertirlo en un número.

Cuando ambos operandos son números, JavaScript realiza la resta. También realiza restas cuando uno o ambos operandos son cadenas que representan un número:

constante numero1 = 10;
constante numero2 = 20;
constante resultado_1 = num2 - num1; // Resta
consola.log (resultado_1); // 10
constante strNum = "10";
constante strNum2 = "20";
constante resultado = strNum2 - strNum; // Escriba coerción a números, luego resta
consola.log (resultado_1); // 10

Cuando ninguno de los operandos es un número o una cadena que representa un número, JavaScript intentará forzar el tipo de datos a su equivalente numérico. Si el tipo de dato no tiene equivalente numérico, la operación devolverá Yaya (No un número):

// true se convierte en 1, false se convierte en 0
constante boolNum = verdadero;
constante boolNum2 = FALSO;
constante resultado_1 = boolNum - boolNum2;
consola.log (resultado_1); // 1
// las matrices vacías se convierten en 0
constante arrNum = [];
constante arrNum2 = [];
constante resultado_2 = arrNum - arrNum2;
consola.log (resultado_2); // 0
// los objetos vacíos son forzados a NaN
constante númobj = {};
constante result_3 = arrNum - objNum;
consola.log (resultado_3); // 0 - NaN = NaN

En este ejemplo, JavaScript fuerza los valores booleanos verdadero y FALSO a sus valores numéricos equivalentes, 1 y 0, respectivamente. Las matrices vacías están obligadas a 0, y los objetos vacíos son obligados a Yaya.

Coerción con los operadores de igualdad (==)/()

En JavaScript, los operadores de igualdad (== y ) comparar valores para la igualdad. Sin embargo, se comportan de manera diferente debido a la coerción de tipo.

El "==El operador ” (igualdad suelta) realiza una coerción de tipo, lo que significa que intenta convertir los operandos al mismo tipo antes de la comparación:

"10" == 10; // verdadero

En este ejemplo, JavaScript convierte la cadena "10" en el número 10, por lo que la expresión se evalúa como verdadero.

Sin embargo, el "El operador ” (igualdad estricta) no realiza coerción de tipos. Requiere que el valor y el tipo sean iguales para que la comparación regrese verdadero:

"10"10; // FALSO

En este ejemplo, la comparación devuelve FALSO porque los operandos son de diferentes tipos (cadena y número).

Por lo general, debe utilizar el (igualdad estricta) en JavaScript para evitar un comportamiento inesperado de coerción de tipos.

La coerción de tipos o la conversión implícita pueden provocar un comportamiento inesperado debido a su naturaleza automática. En los casos en que necesite convertir tipos, es recomendable convertir explícitamente los tipos. El proceso de convertir explícitamente los tipos se conoce como conversión de tipos. También se conoce como conversión de tipo y conversión de tipo explícita.

Conversión de tipo

La conversión de tipos, también conocida como conversión de tipos, es el proceso explícito de convertir un valor de un tipo de datos a otro en JavaScript usando funciones integradas como Número(), Cadena(), booleano(), parseInt(), y parseFloat().

Puede realizar la conversión de tipos pasando el valor que desea convertir a las funciones de conversión integradas como argumento. Estas funciones luego convierten su valor al tipo deseado.

Aquí hay un ejemplo usando el Número() función:

constante numStr = "123";
constante número = Número(cadenanum); // Convierte una cadena en un número
consola.log (núm); // 123

Pasar una cadena que es un número válido como argumento al Número() La función devolverá un número. Pasar una cadena que es un número inválido devolverá Yaya.

Aquí hay un ejemplo usando el Cadena() función:

constante bool = verdadero;
constante str2 = Cadena(bool); // Convierte un booleano en una cadena
consola.registro (str2); // "verdadero"

Pasar cualquier tipo de datos al excepto un símbolo al Cadena() La función convertirá el tipo de datos en una cadena.

Aquí hay un ejemplo usando el booleano() función:

// Convierte una cadena en un valor booleano (verdadero: verdadero, falso: falso)
constante cadena = "Hola";
constante bool2 = booleano(calle);
consola.log (bool2); // verdadero

Pasar valores veraces a la booleano() la función devuelve el booleano "verdadero" mientras que pasar valores falsos devuelve el booleano "falso".

Aquí hay un ejemplo usando el ParseInt() y ParseFloat() función:

// Convierte una cadena en un entero
constante numStr = "123.00";
constante numero1 = parseInt(cadenanum);
consola.log (núm1); // 123
// Convierte una cadena en un número de coma flotante
constante floatStr = "3.14";
constante numero2 = analizar flotar(floatStr);
consola.log (núm2); // 3.14

El parseInt() La función analiza un argumento de cadena y devuelve un número entero. El parseFloat() La función convierte una cadena en un número de coma flotante.

Aprovechamiento de la coerción y la conversión de tipos

Al comprender la coerción y la conversión de tipos, puede tomar decisiones informadas sobre cuándo y cómo aprovecharlas de manera efectiva en su código. Es importante lograr el equilibrio adecuado, utilizando la coerción de tipos de manera juiciosa para un código conciso y conveniente y confiando en la conversión de tipos explícita para las conversiones de tipos predecibles e intencionales.