Diseño y Proagramación Web Madrid. Front-end Developer Madrid. Arquitecto Javascript Madrid - EtnasSoft

La coerción de datos es uno de los aspectos más intrigantes de Javascript. Al corresponderse con un lenguaje de tipado blando, no es necesario especificar el tipo de datos que contendrán nuestras variables. Esto hace posible que en tiempo de ejecución, podamos modificar dicho tipo para operar con ellos a voluntad.

Por lo general, es el intérprete de Javascript el que realiza la conversión de tipos por nosotros de forma interna buscando adaptarse a nuestras operaciones.

Por ejemplo, echemos un vistazo al siguiente código:

var a = "1",
    b = 5;
 
console.log( typeof a, typeof b); // string number
console.log( a + b ); // 15

El resultado puede no ser el esperado: intérnamente, Javascript realiza la conversión del número a cadena y concatena los operandos.

Pero esto es así porque el operador + es a la vez concatenador y suma, prevaleciendo la primera de sus funciones cuando la situación lo permite.

Cuando utilizamos el operador de resta, la cosa cambia:

console.log( "2" - 2 ); // 0

En este caso, la coerción se realiza desde la cadena al número para permitir la operación. Con la multiplicación y la división, ocurre igual:

console.log( '10' * 3 ); // 30
console.log( '10' / 2 ); // 5

Otro ejemplo interesante es cuando involucramos valores lógicos:

console.log( true + true ) // 2

El valor devuelto es el resultado de la suma cuyos operandos corresponden con la conversión de los operadores booleanos a su entidad numérica ( true === 1 ). De nuevo, el intérprete realiza la coerción por nosotros en segundo plano.

De ahí se deduce que,

console.log( '1' + true ); // 1true
console.log( '10' - true ); // 9

Más coerción!

Los resultados hay que reconocer que pueden resultar, cuanto menos, desconcertantes. La siguiente tabla con diversas curiosidades derivadas de la coerción ha sido elaborada por Angus Crall:

true == 1; //true! (converts true to bit value 1)
true - false === 1 //true!!!
"2" + 2; //22!
"2" - 2; //0
"2" - - 2; //4
NaN == NaN; //false - this one sort of makes sense since NaN is any non-Number cast to a number
NaN  NaN; //false - whatever!
"" == 0 //true
undefined == null //false!
"0" == 0 //true!
"false" == false //false!!!'
'\t\r\n ' == 0 //true!!! - essentially an empty string which coerces to 0

NOTA: Algunos de las comprobaciones anteriores no pueden realizarse desde la consola de Firebug ya que arrojan errores de sintaxis. Realmente, se trata de un problema de Firebug para ejecutar algunas instrucciones de este tipo.

Con los condicionales, la situación es similar:

if (0) {....} //false
if(-1) {....} //true
if("") {....} //false
if("null") {....} //true

Forzando la coerción

Como otros lenguajes no tipado, Javascript permite realizar una conversión explícita de los tipos de datos mediante funciones nativas como parseInt, parseFloat, etc…

Es posible realizar la conversión entre casi todos los tipos existentes. La siguiente tabla (vista aquí) nos muestra cómo conseguir cada una de estas conversiones:

Conclusión

La coerción de datos puede ser algo realmente poco intuitivo y capaz de generar los errores más difíciles de rastrear. Conocer algunas de las conversiones que realiza el intérprete Javascript en segundo plano puede ayudarnos a evitar estos comportamiento no deseados en el tratamiento de nuestros datos.

Además de la conversión automática, disponemos de operadores lógicos y unarios que pueden ayudarnos a pasar de un tipo de dato a otro según necesitemos, algo que en muchas ocasiones, no resulta tan sencillo como debiera.

Entradas relacionadas:

1. Duck Typing en Javascript Chequeando los tipos de datos
2. Operadores de igualdad en Javascript
3. Entendiendo el tipado blando en Javascript
4. Falsy Values en Javascript
5. Length en Javascript