Variables, tipos de datos y coerción

Retomando let, const y var

En la página anterior ya viste que existen tres formas de declarar una variable: var, let y const, y que hoy se recomienda usar let/const en vez de var (ver Un primer vistazo al código). Ahí quedó pendiente el motivo concreto: var tiene un comportamiento de scope de función, mientras que let y const tienen scope de bloque.

Esto significa que una variable declarada con var dentro de un bloque {} (por ejemplo, dentro de un if) no queda encerrada en ese bloque: sigue existiendo afuera. Una variable declarada con let sí respeta el bloque donde nació.

Para comprobarlo sin que el error corte la ejecución de todo el script, el segundo caso usa try/catch: el bloque try intenta ejecutar el código, y si lanza un error, el bloque catch lo recibe en vez de detener el programa.

function probarVar() {
  if (true) {
    var mensaje = "estoy dentro del if";
  }
  console.log(mensaje); // "var" ignora el bloque {}, la variable sigue viva afuera
}

probarVar();

function probarLet() {
  try {
    if (true) {
      let mensaje = "estoy dentro del if";
    }
    console.log(mensaje);
  } catch (error) {
    console.log("Error:", error.message);
  }
}

probarLet();

estoy dentro del if
Error: mensaje is not defined

Tipos de datos primitivos

JavaScript tiene un puñado de tipos de datos primitivos. A diferencia de lenguajes donde hay que declarar el tipo explícitamente, acá el tipo se infiere solo, a partir del valor que se le asigna a la variable.

number: un solo tipo numérico

A diferencia de lenguajes que separan enteros y decimales en tipos distintos (int, double, float), JavaScript tiene un único tipo numérico: number. Sirve tanto para 30 como para 3.14.

string, boolean, undefined y null

• string: texto, entre comillas simples, dobles o backticks.
• boolean: true o false.
• undefined: el valor que tiene una variable a la que no se le asignó nada todavía.
• null: un valor que representa “nada”, pero asignado a propósito por quien escribió el código.

La diferencia entre undefined y null es sutil pero importante: undefined es lo que JavaScript pone solo, por ausencia de valor; null es lo que un programador escribe explícitamente para decir “acá no hay nada, y lo sé”.

object

El resto de los datos estructurados (arrays, objetos, funciones) caen bajo el tipo object en JavaScript, aunque cada uno tiene su propia forma de crearse y usarse — se ven en detalle más adelante en esta sección.

typeof: inspeccionar el tipo en tiempo de ejecución

El operador typeof devuelve, como string, el tipo de una variable en el momento en que se ejecuta esa línea.

let edad = 30;
let nombre = "Ana";
let activo = true;
let indefinida;
let vacio = null;
let persona = { nombre: "Ana" };

console.log(typeof edad);
console.log(typeof nombre);
console.log(typeof activo);
console.log(typeof indefinida);
console.log(typeof vacio);
console.log(typeof persona);

number
string
boolean
undefined
object
object

Tipado dinámico en la práctica

Ya viste que JavaScript es de tipado dinámico: una variable no tiene un tipo fijo, tiene el tipo del valor que contiene en ese momento. Eso significa que la misma variable puede cambiar de tipo durante la ejecución, y el programa compila y corre sin ningún error:

let x = 5;
console.log(typeof x);

x = "cinco";
console.log(typeof x);

number
string

Coerción de tipos

Uno de los rasgos más particulares de JavaScript es que, al usar un operador entre valores de distinto tipo, el lenguaje intenta convertir uno de los dos automáticamente en vez de dar un error. A esto se le llama coerción de tipos.

console.log("5" + 3);
console.log("5" - 3);

53
2

Comparación: == vs ===

JavaScript tiene dos operadores para comparar igualdad: == (comparación floja, con conversión de tipos) y === (comparación estricta, sin conversión). Casi siempre conviene usar ===.

console.log(0 == "0");
console.log(0 === "0");

true
false

Ejemplo completo

function calcularTotal(precioTexto, cantidad) {
  const precio = Number(precioTexto); // convierte explícitamente el string a número
  const total = precio * cantidad;
  return total;
}

const precioDesdeFormulario = "150"; // en un formulario web, todo llega como string
const cantidad = 3;

const total = calcularTotal(precioDesdeFormulario, cantidad);
console.log(total);
console.log(typeof total);
console.log(total === 450);

450
number
true

Siguiente paso

Con variables y tipos ya cubiertos, el siguiente paso es controlar el flujo de ejecución: condiciones y bucles (control de flujo) — página todavía no escrita en esta sección.