Tipos primitivos básicos: tipado dinámico, Number, String, Boolean

En JavaScript, el tipado dinámico permite que las variables cambien de tipo durante la ejecución del programa. No es necesario especificar el tipo al declarar una variable; JavaScript determina el tipo en función del valor asignado.

Números (Number)

El tipo Number representa tanto números enteros como de punto flotante. Se utiliza para realizar operaciones matemáticas y cálculos numéricos:

let edad = 30;            // Número entero
let temperatura = -5.5;   // Número decimal
let precio = 1200.50;     // Precio con decimales

Cadenas de texto (String)

Las Strings son cadenas de texto que se utilizan para representar caracteres y palabras. Se pueden definir usando comillas simples, dobles o backticks:

let nombre = "Juan";                // Con comillas dobles
let apellido = 'Pérez';             // Con comillas simples
let saludo = `Hola, ${nombre}!`;    // Template literal con interpolación

Los template literals (con backticks) son especialmente útiles porque permiten insertar variables directamente en el texto, como vimos en nuestro primer programa de "Hola mundo".

Booleanos (Boolean)

El tipo Boolean tiene solo dos valores posibles: true o false. Es fundamental para realizar evaluaciones lógicas y controlar el flujo de ejecución:

let esMiembro = true;
let tieneAcceso = false;

// Los booleanos son útiles para tomar decisiones
if (esMiembro) {
    console.log("Bienvenido, miembro!");
}

Gracias al tipado dinámico, una variable puede cambiar su tipo en cualquier momento:

let variable = 100;    // variable es un Number
variable = "Cien";     // ahora es una String
variable = false;      // ahora es un Boolean

Tipos especiales: ausencia de valor

JavaScript tiene dos valores especiales para representar "ausencia de valor", cada uno con un propósito diferente:

undefined

El valor undefined se asigna automáticamente a variables que han sido declaradas pero no inicializadas:

let usuario;
console.log(usuario);         // undefined
console.log(typeof usuario);  // "undefined"

// También aparece cuando accedemos a propiedades inexistentes
let persona = {nombre: "Ana"};
console.log(persona.edad);    // undefined

null

Por otro lado, null es un valor que asignamos intencionalmente para indicar la ausencia de un objeto o valor:

let datosUsuario = null;  // Todavía no tenemos datos
console.log(datosUsuario); // null

// Útil para resetear o vaciar una variable
let seleccion = "Opción 1";
seleccion = null;  // El usuario canceló la selección

Aunque ambos representan "ausencia", tienen diferencias importantes:

• undefined generalmente indica algo que no ha sido inicializado
• null indica una ausencia intencional de valor

Nuestro primer tipo complejo: Objetos

Además de los tipos primitivos, JavaScript tiene objetos que nos permiten agrupar múltiples valores relacionados:

// Un objeto simple que describe a una persona
let persona = {
  nombre: "Ana",
  edad: 25,
  esEstudiante: true
};

// Accediendo a las propiedades
console.log(persona.nombre);  // "Ana"
console.log(persona.edad);    // 25

Nota: Los objetos son un tema extenso que exploraremos con más detalle en módulos posteriores. Por ahora, solo necesitas comprender que son colecciones de pares clave-valor.

Verificación de tipos con typeof

JavaScript nos proporciona el operador typeof para verificar el tipo de un valor:

console.log(typeof 42);        // "number"
console.log(typeof "Hola");    // "string"
console.log(typeof true);      // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof {});        // "object"
console.log(typeof null);      // "object" (esto es una peculiaridad histórica de JavaScript)

Verificar tipos es útil cuando necesitas asegurarte de que una variable contiene el tipo de dato esperado antes de realizar operaciones con ella.

let entrada = "42";
if (typeof entrada === "string") {
    // Convertir a número si es una cadena
    entrada = Number(entrada);
}

Tipos avanzados

Los siguientes tipos son más avanzados y menos frecuentes, pero es importante conocerlos para tener una visión completa del sistema de tipos en JavaScript.

Symbol

El tipo Symbol, introducido en ES6, se utiliza para crear identificadores únicos e inmutables:

const id = Symbol('id');
let usuario = {
  nombre: 'Alice',
  [id]: 12345  // Propiedad con Symbol como clave
};

console.log(usuario.nombre);  // "Alice"
console.log(usuario[id]);     // 12345

Los Symbols son útiles en código más avanzado para crear propiedades que no colisionarán con otras, incluso si tienen el mismo nombre.

BigInt

El tipo BigInt permite representar números enteros extremadamente grandes, más allá del límite del tipo Number:

// Los BigInt se crean añadiendo 'n' al final o usando la función BigInt()
const numeroGrande = 9007199254740991n;
const otroNumeroGrande = BigInt('9007199254740991');

console.log(numeroGrande + 1n);  // 9007199254740992n

BigInt es útil cuando trabajas con números muy grandes como identificadores, timestamps precisos o cálculos científicos.

Tipos por referencia vs tipos por valor

El siguiente concepto es fundamental y será crucial para entender el comportamiento de objetos y arrays más adelante en el curso.

En JavaScript, los tipos de datos se dividen en dos categorías según cómo se almacenan en memoria:

Tipos primitivos (por valor)

Los tipos primitivos (Number, String, Boolean, null, undefined, Symbol, BigInt) se pasan "por valor". Esto significa que cuando asignas o copias estos valores, obtienes una copia independiente:

let x = 10;
let y = x;  // 'y' obtiene una copia del valor de 'x'

y = 20;     // Cambiar 'y' no afecta a 'x'
console.log(x);  // 10
console.log(y);  // 20

Tipos de referencia (por referencia)

Los objetos (incluyendo arrays y funciones) se pasan "por referencia". Cuando asignas o copias estos valores, ambas variables apuntan al mismo objeto en memoria:

let obj1 = { mensaje: "Hola" };
let obj2 = obj1;  // 'obj2' apunta al mismo objeto que 'obj1'

obj2.mensaje = "Adiós";  // Cambiar a través de 'obj2'...
console.log(obj1.mensaje);  // "Adiós" - ¡También afecta a 'obj1'!			

Profundizaremos en este concepto cuando estudiemos arrays y objetos con más detalle, y será especialmente importante cuando veamos cómo trabajar con funciones que modifican datos.

Conversiones básicas entre tipos

A menudo necesitarás convertir valores de un tipo a otro. JavaScript proporciona varias formas de hacerlo:

Convertir a String

let num = 42;
let str1 = String(num);    // Usando la función String()
let str2 = num.toString(); // Usando el método toString()
let str3 = num + "";       // Concatenando con una cadena vacía

Convertir a Number

let str = "42";
let num1 = Number(str);    // Usando la función Number()
let num2 = parseInt(str);  // parseInt() para enteros
let num3 = parseFloat("42.5"); // parseFloat() para decimales
let num4 = +"42";          // Usando el operador unario +

Convertir a Boolean

JavaScript considera algunos valores como "falsy" (equivalentes a false) y el resto como "truthy" (equivalentes a true):

// Valores falsy:
Boolean(0);          // false
Boolean("");         // false (cadena vacía)
Boolean(null);       // false
Boolean(undefined);  // false
Boolean(NaN);        // false

// Cualquier otro valor es truthy:
Boolean(1);          // true
Boolean("Hola");     // true
Boolean([]);         // true (array vacío)
Boolean({});         // true (objeto vacío)

Este concepto de valores "truthy" y "falsy" será muy importante cuando aprendamos sobre estructuras de control como if y bucles.