La Coerción o Tipo de Conversión es el cambio de un tipo de datos a otro diferente. El tipo de conversión puede ser Implícita o Explícita, voy a describir sobre ambas y dar unos simples ejemplos.

Explícita

El tipo de conversión Explícita es cuando cambiamos el tipo de dato por el lenguaje o por decir de una forma obvia.

de Cadena de Carácteres a Números, de Números a Cadenas de Carácteres

Lo más usual en el tipo de conversión explícita, para coaccionar números y cadenas de carácteres utilizamos dos constructores nativos de JavaScript que son String() y Number(), en este caso no es necesario usar la palabra reservada new ya que no vamos a crear objetos.

var a = 20;
var b = '12';

String(a) // "20"
Number(b) // 12

es obvio el tipo de conversión, el constructor String() coacciona cualquier valor a un valor primitivo de tipo cadena de carácteres pasando por la regla del ToString y el constructor Number() coacciona cualquier valor a un valor primitivo de tipo de número pasando por la regla del ToNumber. Otras formas coerción explícita es usando el objeto global toString() y en caso para los números el unario +, veamos el ejemplo:

var a = 20;
var b = '12';

a.toString() // "20"
+b // 12

La comunidad de JavaScript toma el unario + como un metodo de coerción muy explícita, teniendo en cuenta que ++ o — también coaccionan pero modifican el operando.

Fecha a Número

EL operador unario + también es de gran utilidad para coercer de Fecha a Número, el constructor global Date() consigue la fecha en UTC (Universal Time Coordinate).

var date = new Date();
+date // 1445821924634

y aun mas explícito puede ser el método getTime() en el constructor global Date(), aunque el más preferible y recomendado es la función estática Date.now() agregada en EcmaScript5.

new Date().getTime() // 1445822462411
Date.now() // 1445822476015

Parseando Cadenas Númericas

Como coaccionar cadenas a números pero con una poca diferencia a como lo hicimos arriba. Vamos a considerar:

var a = '20';
var b = '12em';

Number(a) // 20
parseInt(a) // 20

Number(b) // NaN
parseInt(b) // 12

el Number() coacciona solo si es una cadena númerica algo como ‘12em’ resulta NaN (Not a Number) en cambio el método global parseInt() comprueba que sea una cadena de carácteres y esta cadena debe comenzar por un número para lograr parsearlo a un entero.

Booleanos

Ahora vamos a ver como coaccionar cualquier valor que no sea Booleano a Booleano, como los constructores globales Number() y String() para Booleanos tenemos el Boolean(), igual omitimos la palabra reservada new.

var a = '0';
var b = [];
var c = {};
var d = '';
var e = 0;
var f = null;
var g;

Boolean(a) // true
Boolean(b) // true
Boolean(c) // true

Boolean(d) // false
Boolean(e) // false
Boolean(f) // false
Boolean(g) // false

claramente Boolean() coacciona explícitamente, otra forma de coaccionar Booleanos explícitamente es con el unario ! (negación) similar al unario + para los números.

var a = '0';
var b = [];
var c = {};
var d = '';
var e = 0;
var f = null;
var g;

!!a // true
!!b // true
!!c // true

!!d // false
!!e // false
!!f // false
!!g // false

Implícita

El tipo de conversión Implícita también llamado Coerción, es cuando cambiamos el tipo de dato por el compilador y de cualquier forma que no sea obvia.

de Números a Cadena de Carácteres, de Cadena de Carácteres a Números

var a = '10';
var b = '22';
var c = 33;
var d = 15;

a + b // "1022"
c + d // 48
a + c // "1033"
d + '' // "15"

// coercion de dos vectores a cadena
[2,3] + [5,5] // "2,35,5"

un poco extraño esto no? esto se basa por el operador + que es de sumar y concatenar, en el ejemplo de arriba podemos ver como hacemos el tipo de conversión a cadenas de carácteres, ahora como pasamos de cadena a número?

var a = '10';
a - 0 // 10

// coercion de dos vectores a numero
[5] - [3] // 2

el (-) operador es es solo para substracción númerica, así forzamos de manera implícita cambiar a número.

de Booleano a Número

var a = true;
var b = false;

a + 1 // 2
a - 1 // 0
b + 1 // 1
a + a + a // 3

por lógica true equivale a 1 y false equivale a 0.

Coerción de Booleanos

Con condicionales(if, while, do…while) podemos evaluar booleanos y retorna la declaración si es true, a veces forzandolo a que devuelva un valor booleano en específico.

var a = 'Ninja';
var b;

if(a) {
    console.log('es true y por lo tanto se ejecuta este bloque de codigo');
}

if(!a) {
    console.log('lo forzamos a false y no se ejecuta este bloque de codigo, solo devuelve undefined');
}

while(b) { 
    console.log('no se ejecuta')
}

los operadores && y || igual que en otros lenguajes de programación pero en JavaScript se encuentra una pequeña diferencia, el valor a retorna no es necesariamente por un tipo de booleano, puede ser por alguna de las dos expresiones.

var a = 'Ninja';
var b = 23;
var c = null;

a || b // "Ninja"
a && b // 23

a || c // "Ninja"
a && c // null

podemos denotar que en otros lenguajes estos operadores nos devuelve un valor booleano, en caso de JavaScript (Ruby, Python también) nos devuelve el valor propio de la variable. Los operadores || y && ejecutan una prueba de booleanos en los operandos, si el operador no es booleano se ejecuta la coerción con el ToBoolean. Para el operador || si el resultado es true retorna el valor del primer operando de lo contrario si es false retorna el valor del segundo operando. Para el operador && lo inverso, si el resultado es true retorna el valor del segundo operando de lo contario si es false retorna el valor del primer operando. También podemos usar el operador ternario (? :)

var a = 'Ninja';
var b = 23;
var c = null;

a || b // "Ninja"
// equivalente a
a ? a : b  // "Ninja"

a && b // 23
// equivalente a
a ? b : a // 23

con el operador ternario podemos omitir los valores false y solo retornar los valores true.

Otro uso del operador es definir variables o argumentos predeterminados ya que en JavaScript no se puede declarar argumentos predeterminados.

var a = b || 'Ninja';

// o en un constructor
function Prueba(a, b) { 
    this.a = a || 'Ninja';
    this.b = b || 20;   
}

Pérdida de igualdad e Igualdad estricta

Una preocupación de concepto sobre JavaScript es la Pérdida de igualdad (==) e Igualdad estricta (===), esto es algo confuso para los que esten iniciando en el lenguaje y tiene que ver con la coerción, simplemente es asi: la pérdidad de igual (==) permite la coerción por esto comparar dos operandos con el mismo valor pero de diferente tipo de dato es true, y la igualdad estricta (===) no permite la coerción por lo tanto dos operandos con el mismo valor pero de diferente tipo de dato es false porque la igualdad estricta evalua también el tipo de datos de los operandos. Para un mejor entendimiento vamos a ver unos ejemplos:

Comparando con Cadenas de Carácteres

var a = 20;
var b = '20';

a == b // true
a === b // false

como observamos la operación a == b (perdida de igualdad) es true porque permite la coerción y la operación a === b (igualdad estricta) es false porque no permite la coerción, el tipo de coerción que sucede en a == b es que b coerciona con ToNumber si a hubiese sido la cadena y b el número se ejecuta igual el ToNumber pero en este caso al valor de a.

Comparando con Booleanos

Otro caso confuso es el de comparar con booleanos, veamos un simple ejemplo:

var a = '20';
var b = true;

a == b // false
a === b // false

que pasa aqui? sabemos que la igualdad estricta es false, pero en la perdida de igualdad támbien resulta false pero porque si el valor de a es una cadena que es true no? la razon es simple: si en una igualdad usando coerción existe un booleano se ejecuta el ToNumber en este caso al operando b que es un booleano de tipo true, sabemos que true es 1 entonces el ToNumber(b) se ejecuta y lo coerciona a 1 por lo tanto la operación es ‘20’ == 1 también la denotamos el ‘20’ por 20 entonces 20 == 1 resulta false.

Comparando Null y Undefined

Otro ejemplo es comparar null y undefined con perdida de igualdad (==).

var a = null;
var b;

a == b // true
b == a // true

a == false // false
b == false // false
a == '' // false
b == '' // false
a == 0 // false
b == 0 // false

la igualdad entre null y undefined es seguro a true.

Comparando Objetos

Los Objetos incluyendo funciones y vectores son comparados con simples valores primitivos, usando la perdida de igual (==) en un tipo de dato ya sea cadena o número y el otro tipo de dato un objeto se ejecuta el ToPrimitive() al objeto, para tener un ejemplo mas claro:

var a = 20;
var b = [20];
var c = Object(20);

a == b // true
a == c // true

como vemos la coerción ejecuta el ToPrimitive al objeto pasandolo a un valor primitivo para evaluarlo con la cadena o un número.

Conclusión

La Coerción en JavaScript es un concepto muy confuso distinto a otro lenguajes de programación, es recomendado no usar la coerción implícita a menos que estes al tanto de lo que haces y aunque no sea recomendado se le puede sacar provecho en algunos pocos casos, lo mejor es optar por la coerción explícita ya que se define por el mismo lenguaje y más aun si estas trabajando con un grupo de trabajo, con este post espero que estes un poco más claro del estrecho concepto de la coerción en JavaScript.