En programación, la conversión de tipos de datos es el proceso mediante el cual se transforma el tipo de dato de un valor a otro. Por ejemplo, un número puede convertirse en una cadena de texto, o una cadena en un valor booleano. Este tipo de conversiones permiten que los programas sean más flexibles al manejar información de distinta naturaleza, evitando errores o resultados inesperados.
En JavaScript, la conversión de tipos cobra importancia porque es un lenguaje débilmente tipado: las variables, constantes y funciones no tienen un tipo de dato fijo, por lo que pueden cambiar durante la ejecución. Pueden transformarse de forma automática (coerción o conversión implícita) o de forma intencional (conversión explícita), es decir, que el programador las realiza manualmente.
En este artículo nos centraremos en esta última: la conversión explícita de tipos. A diferencia de la coerción, que ocurre de manera automática y a veces impredecible, la conversión explícita se realiza de manera consciente y controlada. JavaScript proporciona funciones y métodos, como Number(), String() o Boolean(), para transformar valores entre distintos tipos de forma más precisa.
Comprender y aplicar correctamente la conversión explícita es una práctica esencial para evitar errores lógicos y garantizar resultados coherentes, especialmente al trabajar con operaciones aritméticas o validaciones de datos.
Conversión explícita a cadena de texto
Para convertir cualquier tipo de dato a una cadena de texto, existen dos formas principales: usar el constructor String() o el método toString(). Según el contexto, nos interesará más una forma o la otra.
El constructor String() es la opción más segura cuando el tipo de dato es incierto (null o undefined), ya que no produce error en estos casos. Basta con indicar como parámetro el dato que queremos convertir a cadena de texto.
String(10); // '10'
String(null); // 'null'
String(true); // 'true'
El método toString(), en cambio, se invoca de forma directa sobre el valor o la variable. Por ejemplo: miNumero.toString(). Sin embargo, no puede usarse con null y undefined, porque no tienen métodos asociados.
(10).toString(); // '10'
(null).toString(); // Error
Una ventaja de usar el método toString() es que permite especificar como parámetro la base numérica en la que se representará el número. Por ejemplo, se puede convertir un número de base decimal (o base 10) en una cadena de texto que muestre su valor en base binaria (o base 2); de esta manera:
(10).toString(2); // '1010'
Conversión explícita a número
Para convertir valores a tipo numérico (number) de forma intencional se pueden usar varias opciones: el constructor Number(), las funciones parseInt() y parseFloat(), o bien el operador «unario más» (+N).
El constructor Number() se usa indicando como parámetro el valor que se desea convertir a tipo number. Puede recibir cadenas de texto que contengan números, valores booleanos o el valor null. En cambio, si el valor es una cadena sin números o el valor undefined, devolverá NaN (Not a Number).
Number('10'); // 10
Number(true); // 1
Number(false); // 0
Number(null); // 0
Number('ABC'); // NaN
En lugar Number(), también puede usarse el operador «unario más» (+N) como prefijo. Funciona de forma equivalente, pero es más breve:
+'10'; // 10
+true; // 1
+false; // 0
+null; // 0
La función parseInt() convierte cadenas de texto a números enteros. Si el texto del parámetro indicado contiene un número con decimales, solo se conserva la parte entera. Además, acepta un segundo parámetro opcional para indicar la base numérica del primer parámetro (por defecto, base 10).
parseInt('10.95'); // 10
parseInt(10.9543); // 10
parseInt('ABCD'); // NaN
parseInt(false); // NaN
parseInt(1010, 2); // 10
Por otro lado, parseFloat() permite convertir cadenas de texto a números de coma flotante (con decimales). Admite un solo parámetro, que si no es una cadena de texto, primero se convierte a texto antes de ser analizado.
parseFloat(3.14); // 3.14
parseFloat("3.14"); // 3.14
parseFloat(" 3.14 "); // 3.14
parseFloat("FF2"); // NaN
Conversión explícita a booleano
Para convertir cualquier tipo de dato a un valor booleano (verdadero o falso) de forma voluntaria se utiliza el constructor Boolean(). Este proceso convierte los valores en función de si son considerados falsy o truthy. De forma alternativa también puede usarse la doble negación (!!).
Los valores falsy —que se convierten en false— son los siete siguientes: 0, '' (cadena vacía), null, undefined, NaN y false. Todos los demás valores se consideran truthy y, por lo tanto, se convierten en true.
Boolean(100); // true
Boolean(0); // false (0 es falsy)
Boolean(""); // false (cadena vacía es falsy)
Boolean(null); // false (null es falsy)
Boolean("Hi"); // true
En lugar Boolean(), también puede usarse el doble operador de negación (!!). El primer ! niega el valor de forma implícita, pero el segundo fuerza una nueva inversión, devolviendo el valor original ya convertido.
!!'ABC'; // true (string es truthy)
!!0; // false
!!null; // false
!!{}; // true
