Lección 07: Conversión de Tipos

🧠 Concepto

En JavaScript podemos convertir un valor de un tipo a otro. Hay dos formas: conversión explícita (nosotros la hacemos intencionalmente) y conversión implícita o coerción (JavaScript la hace automáticamente).

Conversión explícita (type casting)

Usamos funciones constructoras para convertir tipos.

A string:

String(123);       // "123"
String(true);      // "true"
String(null);      // "null"
String(undefined); // "undefined"

A number:

Number('123');     // 123
Number('12.5');    // 12.5
Number('Hola');    // NaN (Not a Number)
Number(true);      // 1
Number(false);     // 0
Number(null);      // 0
Number(undefined); // NaN

parseInt('123');        // 123 (entero)
parseInt('12.9');       // 12 (trunca decimales)
parseFloat('12.5');     // 12.5 (decimal)
parseInt('123px');      // 123 (ignora el 'px')
parseInt('  42  ');     // 42 (ignora espacios)

A booleano:

Boolean(1);       // true
Boolean(0);       // false
Boolean('Hola');  // true
Boolean('');      // false
Boolean(null);    // false
Boolean(undefined); // false

Coerción implícita (conversión automática)

JavaScript convierte tipos automáticamente en ciertas operaciones.

console.log('5' - 2);    // 3 (string '5' se convierte a número)
console.log('5' + 2);    // "52" (número 2 se convierte a string)
console.log('5' * '2');  // 10 (ambos strings se convierten a números)
console.log('5' == 5);   // true (coerción con ==)
console.log('5' === 5);  // false (sin coerción)

Por qué NaN no es igual a NaN

console.log(NaN === NaN); // false

NaN es el único valor en JavaScript que no es igual a sí mismo.

💻 Ejemplo

// Conversión explícita
console.log(Number('3.14'));    // 3.14
console.log(String(100));       // "100"
console.log(Boolean(0));        // false

// Conversión con parseInt/parseFloat
console.log(parseInt('100px')); // 100
console.log(parseFloat('3.14')); // 3.14

// Coerción implícita — ¡cuidado!
console.log('10' - 5);   // 5
console.log('10' + 5);   // "105"  ← ¡trampa!
console.log('10' * 2);   // 20
console.log('10' / 2);   // 5

// NaN
console.log(Number('no soy número')); // NaN
console.log(isNaN('Hola'));           // true

📝 Ejercicio

1. Crea un archivo conversion-tipos.js.
2. Declara una variable strNumero = '42'.
3. Conviértela a número con Number() e imprime el resultado y su tipo.
4. Convierte el número 123 a string y muéstralo.
5. Convierte 1 y 0 a booleanos y muéstralos.
6. Prueba estas expresiones y adivina el resultado antes de ejecutar:
   • '8' + 3
   • '8' - 3
   • '8' * '3'
   • 'Hola' + 5

let strNumero = '42';
let num = Number(strNumero);
console.log('Valor:', num, '- Tipo:', typeof num);

let numAString = String(123);
console.log('Valor:', numAString, '- Tipo:', typeof numAString);

console.log(Boolean(1));  // true
console.log(Boolean(0));  // false

⚠️ Nota

El operador + es especial: si alguno de los operandos es un string, hace concatenación, no suma. Los otros operadores aritméticos (-, *, /) siempre convierten a número. Esta es la fuente más común de errores en JavaScript.

🎯 Tip

Usa Number.isNaN(valor) para comprobar si un valor es NaN. isNaN() global también funciona pero primero convierte el valor, lo que puede dar resultados engañosos:

isNaN('Hola');         // true (convierte 'Hola' a NaN)
Number.isNaN('Hola');  // false (no convierte, 'Hola' no es NaN)