La coerción de tipos (o conversión implícita) ocurre cuando JavaScript convierte de forma automática un valor de un tipo de dato a otro tipo. Este proceso se produce al realizar una operación, como un cálculo aritmético o una comparación, cuando el motor necesita un tipo de dato diferente para evaluarla.
¿Por qué se produce la coerción? Porque JavaScript es un lenguaje de tipado dinámico (débilmente tipado), lo que significa que los valores de las variables, constantes o funciones no tienen un tipo de dato fijo. De hecho, los tipos de datos pueden cambiar varias veces durante la ejecución del programa.
Estas conversiones automáticas son esenciales para que el lenguaje pueda realizar operaciones de forma flexible. Sin embargo, comprender cómo y cuándo ocurren es fundamental, ya que la coerción puede generar resultados inesperados o errores de lógica. En contraste, la conversión explícita se realiza de forma intencional, usando funciones y métodos integrados en el propio lenguaje.
Un ejemplo de coerción. Si usamos el operador de adición (+) cuyos operandos son un número (tipo number) y una cadena de texto (tipo string), el motor convertirá el número a cadena y realizará una concatenación.
20 + 'hola'; // '20hola'
El resultado es una cadena de texto con el valor «20hola».
En cambio, si el operador es el de sustracción (-) y la cadena de texto contiene un número válido (sin caracteres no numéricos), la cadena se convertirá a tipo number para efectuar la operación aritmética de forma correcta.
20 - '5'; // 15
Ahora sí ha realizado una operación aritmética.
Vamos a verlos con más detalle.
Coerción a cadena de texto
La coerción a cadena de texto ocurre cuando JavaScript necesita un valor de tipo string. Esto sucede, por ejemplo, al usar el operador de adición (+) cuando uno de los dos operandos es una cadena de texto y el otro no.
Las reglas de la coerción a cadena de texto son muy simples: todos los tipos de datos pueden ser convertidos a una representación textual usando su valor. Por ejemplo, true se convierte en 'true' y null en 'null'.
Por ejemplo:
'10' + 5000; // '105000'
'10' + false; // '10false'
'10' + null; // '10null'
En estos ejemplos, JavaScript convierte a cadena de texto (tipo string) los operandos «5000», «false» y «null» para realizar la concatenación.
Coerción a número
La coerción a número se produce de forma automática cuando un valor de un tipo no numérico debe convertirse a number, porque así lo requiere la operación que se está realizando. Esto sucede con la mayoría de los operadores aritméticos (-, *, /, %) y de comparación relacional (<, >, <=, >=).
Existe una excepción importante: el operador de adición (+) no realiza la conversión implícita número cuando uno de los operandos es una cadena de texto. En tal caso, JS realiza una concatenación.
Estas son las reglas de la coerción a número:
| Valor | Conversión |
|---|---|
| Cadenas de texto con números (‘123’) | Números |
| Cadenas de texto sin números (‘abc’) | NaN |
| Cadenas vacías o con espacios (‘’) | 0 |
El valor booleano true | 1 |
El valor booleano false | 0 |
La ausencia de valor (null) | 0 |
Valor no asignado (undefined) | NaN |
Veamos algunos ejemplos para entenderlo mejor:
'10' / 5; // 2 (10 / 5)
'10' - '5'; // 5 (10 - 5)
'10' - true; // 9 (10 - 1)
'10' * false; // 0 (10 * 0)
'tp' / 50; // NaN (NaN / 50)
En este ejemplo, las cadenas de texto ‘10’ y ‘5’ se convierten a números. Los valores booleanos true y false se convierten en 1 y 0, respectivamente. La cadena de texto ‘tp’ no contiene números, por tanto no puede realizar una operación y como resultado devuelve NaN (Not a Number).
Conversión de ‘null’ a número
El tipo de dato null (ausencia de valor) se convierte de forma automática a 0 cuando se usa como operando en un contexto que requiere un número.
Por ejemplo:
10 * null; // 0 (10 * 0)
10 - null; // 10 (10 - 0)
10 + null; // 10 (10 + 0)
Conversión de ‘undefined’ a número
El tipo de dato undefined (valor no asignado) siempre se convierte a NaN (Not a Number) cuando se usa con operadores aritméticos. De hecho, cualquier operación aritmética que incluya NaN será NaN.
10 * undefined; // NaN (10 * NaN)
10 - undefined; // NaN (10 - NaN)
10 + undefined; // NaN (10 + NaN)
Coerción a booleano
La coerción a booleano se produce cuando un valor es evaluado en un contexto lógico, lo que requiere que el valor se interprete como verdadero o falso. Esto ocurre al aplicar el operador lógico NOT (!) de negación o al evaluar una estructura condicional, como puede ser un if o un while.
Los valores se convierten de forma automática a true o false dependiendo de su valor de verdad, conocido como la regla truthy o falsy.
Por tanto, la regla principal para la conversión automática de valores booleanos es la siguiente: los valores falsy como false, 0, '' (cadena vacía), null, undefined y NaN se convierten a false (falso). Por el contrario, el resto son truthy, en consecuencia se convierten a true (verdaderos).
Por ejemplo:
!true; // false
!false; // true
!0; // true (0 es falsy)
!1; // false (1 es truthy)
!''; // true (cadena vacía es falsy)
!'ABC'; // false (string es truthy)
!null; // true (null es falsy)
!NaN; // true (NaN es falsy)
!{}; // false (un objeto vacío es truthy)
![]; // false (un array vacío es truthy)
Como se puede ver, la negación de los valores falsy devuelve true, mientras que la negación de los valores truthy devuelve false.
