🔍 Conversión, Parsing, Coerción y Evaluaciones en JavaScript

¿Pensabas que JavaScript solo convertía tipos cuando usabas +? Oh, no. Este lenguaje, encantador y caótico, realiza conversiones todo el tiempo, y muchas veces sin que lo notes.

En esta guía te explico:

• La diferencia entre parsing y conversión
• Qué es una coerción implícita
• Cómo se comportan los valores en contextos boolean
• Cómo funcionan los operadores &&, || y ==

---

📥 Parsing vs Conversión

⚠️ ¡No son lo mismo!

Parsing es un proceso explícito donde transformamos una cadena en un valor con reglas claras, usando funciones como:

parseInt("42");       // 42
parseFloat("3.14");   // 3.14
Number("123");        // 123 (conversión, no parsing)

Conversión es más general y a veces implícita. Puede ser:

• ToNumber
• ToString
• ToBoolean

La diferencia clave es que parseInt() y parseFloat() ignoran caracteres no numéricos, mientras que Number() exige que toda la cadena sea un número válido.

---

♾️ ¿Qué pasa con parseInt(Infinity)?

parseInt(Infinity); // NaN

¿Por qué? Porque parseInt() espera un string. Infinity convertido a string es "Infinity", y parseInt("Infinity") falla porque no empieza por un número válido.

👉 Siempre verificá el tipo antes de parsear.

---

🔄 Conversión a boolean (implícita)

JavaScript realiza conversión implícita a booleanos en los siguientes contextos:

• En condiciones (if, while, ?:)
• En operadores lógicos (&& y ||)
• Como operandos de !

Boolean("");      // false
Boolean("0");     // true
Boolean([]);      // true
Boolean(null);    // false
Boolean({});      // true

Pero esto puede llevarte a errores si usás new Boolean(false): aunque false parezca falso, ¡el objeto resultante es truthy!

---

⚖️ Evaluación con && y ||: corto circuito y valores de retorno

Ambos operadores no devuelven un booleano, sino uno de los valores originales:

"JS" && 42      // 42
0 || "fallback" // "fallback"

Esto los convierte en excelentes atajos para:

• Asignar valores por defecto
• Ejecutar funciones condicionalmente
• Evitar estructuras if anidadas

Sin embargo, también pueden complicar la lectura si no entendés cómo funciona el “short-circuit” (evaluación perezosa).

---

🧠 ¿Qué pasa con ==?

== permite conversión de tipos, mientras que === no.

1 == "1"       // true
1 === "1"      // false

false == 0     // true
false === 0    // false

JavaScript aplica reglas específicas de conversión para que los valores puedan compararse incluso si tienen tipos diferentes. Esta es la famosa coerción en igualdad abstracta (sección 7.2.14 de la especificación).

🔎 Hay una tabla oficial con las conversiones que realiza == entre diferentes tipos (¡la viste en la imagen!). Memorizarla no es necesario, pero saber que existe puede salvarte el día.

---

📘 Verdadero vs. Truthy

Hay una diferencia entre un valor igual a true y uno que se comporta como true. Lo mismo para false y falsy.

Boolean(0);            // false
Boolean(new Number(0)); // true (!)

Objetos con valores falsos internamente siguen siendo truthy. Y eso puede traerte bugs invisibles.

---

💡 Experimentos y cosas locas con +

"" + 1     // "1"
1 + true   // 2
1 + false  // 1
1 + null   // 1
1 + undefined // NaN
[] + []    // ""
[] + {}    // "[object Object]"

El operador + no es solo suma: también es el operador de concatenación. Si cualquiera de los operandos es string, se activa la operación ToString. Si no, se convierte a número.

🔥 Muchos memes de JS salen de aquí, pero son reales y pasan en producción.

---

📌 Consejos generales

• Preferí === sobre ==, salvo que sepas lo que hacés.
• Verificá tipos explícitamente: typeof, Array.isArray(), etc.
• Si necesitás conversión, hacela vos con String(), Number(), Boolean().
• No uses new Boolean, new Number, ni new String para lógica.
• Si usás || para valores por defecto, documentá ese uso (especialmente si 0 o "" podrían ser valores válidos).

---

🔗 Recursos adicionales

• 📘 MDN: Data Types and Structures
• 📚 ECMAScript Spec: Abstract Equality
• 🧠 Deep JavaScript – Type Conversions