Saltar al contenido
Fundamentos del lenguaje

Conversión de tipos

Lección 8 de 912 min4 ejercicios

JavaScript es un lenguaje flexible con los tipos: si una operación espera un número y le das un texto, intenta convertirlo por su cuenta. A veces eso ayuda, y a veces produce resultados absurdos como "5" + 2 = "52". Entender cuándo pasa te da el control.

Qué mirar en el pizarrón

Los dos valores son "5" (texto) y 2 (número). Mira cómo cambia el resultado según el operador: + se comporta distinto que todos los demás.

En el pizarrón

const a = "5";const b = 2;console.log(a + b);console.log(a - b);console.log(a * b);console.log(Number(a) + b);

Variables

  1. astring · "5"
  2. bnumber · 2
Consola(vacía)

a parece un número, pero está entre comillas: es un texto. Así llegan, por ejemplo, los datos de un formulario.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: a parece un número, pero está entre comillas: es un texto. Así llegan, por ejemplo, los datos de un formulario. Variables: a string · "5", b number · 2.
  2. Paso 2: Si uno de los dos lados de + es texto, + concatena: convierte el 2 en "2" y pega. Resultado: "52". Variables: a string · "5", b number · 2.
  3. Paso 3: - solo sabe restar números, así que convierte "5" en 5. Resultado: 3. Es una conversión implícita: el motor la hace sin avisarte. Variables: a string · "5", b number · 2.
  4. Paso 4: Con * pasa lo mismo: "5" * 2 da 10. Solo + se comporta distinto con textos. Variables: a string · "5", b number · 2.
  5. Paso 5: La forma segura: convertir explícitamente con Number(a) antes de operar. Así el código dice lo que hace, y + suma: 7. Variables: a string · "5", b number · 2.

Implícita y explícita

Hay dos formas de convertir un valor de un tipo a otro:

  • Implícita (o coerción): el motor la hace solo, cuando una operación necesita otro tipo. No la ves en el código.
  • Explícita: la escribes tú, con Number(), String() o Boolean(). Queda claro qué pasa.

La regla de oro: convierte explícitamente. El código se lee mejor y no depende de que recuerdes las reglas de la coerción.

A número

console.log(Number("42"));       // 42
console.log(Number("3.5"));      // 3.5
console.log(Number("12px"));     // NaN: todo el texto debe ser un número
console.log(Number(""));         // 0 (¡ojo!)
console.log(Number(true));       // 1
console.log(Number(null));       // 0
console.log(Number(undefined));  // NaN

Para leer un número al principio de un texto, como "12px" o "3.5 kg", usa parseInt (enteros) o parseFloat (decimales). Leen desde el inicio y se detienen en el primer carácter que no entienden:

console.log(parseInt("12px"));        // 12
console.log(parseFloat("3.5 kg"));    // 3.5
console.log(parseInt("ff", 16));      // 255: el segundo argumento es la base
console.log(parseInt("hola"));        // NaN

El + delante de un valor (+ unario) también convierte a número: +"42" da 42. Es corto, pero menos legible que Number().

A texto y a booleano

console.log(String(42));          // "42"
console.log(String(null));        // "null"
console.log(String([1, 2, 3]));   // "1,2,3"
console.log((255).toString(16));  // "ff"

console.log(Boolean("hola"));     // true
console.log(Boolean(0));          // false

Para booleanos se aplica la regla de truthy y falsy que viste en el tema anterior.

La trampa del +

Es lo que muestra el pizarrón. + tiene dos trabajos: sumar números y concatenar textos. Si cualquiera de los dos lados es un texto, concatena:

console.log("5" + 2);        // 52
console.log(1 + 2 + "3");    // 33: primero 1 + 2 = 3, después "3" + "3"
console.log("1" + 2 + 3);    // 123: desde el principio es texto

Los demás operadores aritméticos (-, *, /, %) solo trabajan con números, así que convierten los textos:

console.log("10" - 4);   // 6
console.log("10" * "2"); // 20
console.log("a" * 2);    // NaN: "a" no se puede convertir

== frente a ===

JavaScript tiene dos operadores de igualdad:

  • === (igualdad estricta): si los tipos son distintos, da false sin convertir nada.
  • == (igualdad amplia): convierte antes de comparar, con reglas difíciles de recordar.
console.log(0 === "");        // false
console.log(0 == "");         // true
console.log("1" == 1);        // true
console.log(false == "0");    // true
console.log(null == undefined); // true
console.log(null == 0);       // false

Por resultados como estos, usa siempre === y !==. Muchos equipos tienen una regla en su linter que prohíbe ==. La única excepción que vas a ver en código ajeno es valor == null, un atajo para preguntar “¿es null o undefined?” a la vez.

Resumen

  • La conversión implícita la hace el motor solo; la explícita la escribes tú. Prefiere la explícita.
  • Number() convierte el texto entero (o da NaN); parseInt y parseFloat leen el número del principio.
  • Ojo: Number("") da 0, no NaN.
  • Con un texto de por medio, + concatena; -, *, / y % convierten a número.
  • Usa siempre === y !==: == convierte antes de comparar y da sorpresas.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Cuando el motor convierte solo

Elige una respuesta en cada pregunta.

  1. ¿Qué da "3" * "4"?

  2. ¿Qué da "0" == 0? ¿Y "0" === 0?

  3. ¿Qué da Number("12px")? ¿Y parseInt("12px")?

  4. ¿Qué da Number("")?

Ordena la salida: Conversiones implícitas y explícitas

Ordena los resultados tal como aparecerían en la consola. Fíjate en qué valores son textos.

console.log("1" + 1);console.log("3" - 1);console.log(+"42");console.log(parseInt("15px"));console.log(String(true) + "!");

Consola, de arriba abajo

  1. true!
  2. 42
  3. 11
  4. 15
  5. 2

Detective: Un precio que llegó como texto

Este programa quiere mostrar un precio con dos decimales, pero se rompe. Encuentra la línea y elige el arreglo que no pierde los decimales.

Consola

tienda.js:2
const precio = precioTexto.toFixed(2);
                           ^

TypeError: precioTexto.toFixed is not a function

Paso 1: toca la línea de código que causa el error.

Laboratorio: Suma lo que llega del formulario

Los dos valores vienen de un formulario y deberían sumarse, pero el programa imprime 105. Arréglalo para que imprima la suma.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime la suma: 15 (pendiente)
  • Convierte los textos explícitamente (con Number, parseFloat o + unario) (pendiente)
  • No escribe el resultado a mano (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.