Variables y tipos de datos

Declaración de variables

Las variables son contenedores que nos permiten almacenar datos en la memoria del programa para utilizarlos más adelante. En JavaScript moderno disponemos de tres palabras clave para declarar variables: let, const y var. Cada una tiene características específicas que determinan cuándo y cómo debemos usarlas.

Declaración con let

La palabra clave let es la forma estándar de declarar variables que pueden cambiar su valor a lo largo del programa:

let nombre = "Ana";
let edad = 25;
let estaEstudiando = true;

También podemos declarar una variable sin asignarle un valor inicial, y posteriormente inicializarla:

let puntuacion;
console.log(puntuacion); // undefined

puntuacion = 85;
console.log(puntuacion); // 85

Las variables declaradas con let tienen alcance de bloque, lo que significa que solo existen dentro del bloque de código donde se declararon:

if (true) {
    let mensaje = "Hola mundo";
    console.log(mensaje); // "Hola mundo"
}

// console.log(mensaje); // Error: mensaje no está definido

Declaración con const

La palabra clave const se utiliza para declarar constantes, es decir, variables cuyo valor no puede cambiar una vez asignado:

const PI = 3.14159;
const EMPRESA = "TechSolutions";
const MAX_USUARIOS = 100;

Es obligatorio asignar un valor al declarar una constante:

// Correcto
const nombre = "Pedro";

// Incorrecto - Error de sintaxis
// const apellido;

Intentar reasignar el valor de una constante genera un error:

const ciudad = "Madrid";
// ciudad = "Barcelona"; // Error: Assignment to constant variable

Declaración con var

La palabra clave var es la forma clásica de declarar variables en JavaScript. Aunque sigue siendo válida, no se recomienda su uso en código moderno debido a su comportamiento menos predecible:

var antiguaVariable = "valor";

Las variables var tienen alcance de función en lugar de alcance de bloque, lo que puede generar comportamientos inesperados:

function ejemplo() {
    if (true) {
        var x = 1;
    }
    console.log(x); // 1 (accesible fuera del bloque)
}

Reglas de nomenclatura

Los nombres de variables en JavaScript deben seguir ciertas reglas obligatorias y convenciones recomendadas:

Reglas obligatorias:

• Deben comenzar con una letra, guión bajo (_) o símbolo de dólar ($)
• Pueden contener letras, números, guiones bajos y símbolos de dólar
• No pueden ser palabras reservadas del lenguaje (if, for, function, etc.)
• Son sensibles a mayúsculas (nombre y Nombre son variables diferentes)

Convenciones recomendadas:

• Utilizar camelCase para nombres de variables: nombreCompleto, fechaNacimiento
• Usar nombres descriptivos que expresen claramente el propósito: precio en lugar de p
• Para constantes, usar MAYÚSCULAS con guiones bajos: MAX_INTENTOS, URL_BASE

// Buenos ejemplos
let nombreUsuario = "María";
let edadMinima = 18;
const TASA_IVA = 0.21;

// Ejemplos a evitar
let n = "María";        // Poco descriptivo
let NombreUsuario = ""; // No sigue camelCase
let nombre-usuario = "";// Carácter no válido

Mejores prácticas

Para escribir código JavaScript mantenible y sin errores, sigue estas recomendaciones:

• Prefiere const por defecto para todos los valores que no cambiarán
• Usa let cuando necesites modificar el valor de la variable
• Evita var completamente en código nuevo
• Declara las variables lo más cerca posible de donde las uses
• Inicializa las variables al declararlas siempre que sea posible

// Enfoque recomendado
const usuario = "admin";
const configuracion = {
    tema: "oscuro",
    idioma: "es"
};

let contador = 0;
let mensaje = "";

// En lugar de
var datos;
var resultado;
datos = obtenerDatos();
resultado = procesarDatos(datos);

Esta aproximación hace que el código sea más legible, reduce los errores potenciales y facilita el mantenimiento del programa a largo plazo.

Tipos primitivos

JavaScript maneja tipos de datos primitivos que representan los valores más básicos del lenguaje. Estos tipos son inmutables, lo que significa que no se pueden modificar directamente, y cuando realizamos operaciones sobre ellos, JavaScript crea nuevos valores en lugar de cambiar los existentes.

Number

El tipo number representa tanto números enteros como decimales en JavaScript. A diferencia de otros lenguajes, no existe distinción entre enteros y flotantes:

let entero = 42;
let decimal = 3.14159;
let negativo = -25;
let cientifico = 2.5e6; // 2500000

JavaScript incluye algunos valores especiales dentro del tipo number:

let infinito = Infinity;
let menosInfinito = -Infinity;
let noEsNumero = NaN; // Not a Number

console.log(10 / 0);        // Infinity
console.log(-10 / 0);       // -Infinity
console.log("texto" * 2);   // NaN

Para trabajar con números seguros en operaciones matemáticas, JavaScript proporciona constantes útiles:

console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

String

El tipo string representa cadenas de texto. Podemos crearlas usando comillas simples, dobles o plantillas literales (template literals):

let nombre = 'Ana';
let apellido = "García";
let saludo = `Hola, ${nombre} ${apellido}`;

Las plantillas literales son especialmente útiles para construir cadenas complejas:

let edad = 25;
let presentacion = `Mi nombre es ${nombre} y tengo ${edad} años.
Esta cadena puede ocupar
múltiples líneas.`;

Podemos acceder a caracteres individuales usando índices y obtener la longitud de la cadena:

let texto = "JavaScript";
console.log(texto[0]);        // "J"
console.log(texto.length);    // 10
console.log(texto[texto.length - 1]); // "t"

Boolean

El tipo boolean tiene únicamente dos valores posibles: true y false. Se utiliza principalmente en condiciones y operaciones lógicas:

let esMayor = true;
let estaActivo = false;
let tienePermisos = edad >= 18; // Resultado booleano de una comparación

Muchas operaciones de comparación devuelven valores booleanos:

let puntuacion = 85;
let aprobado = puntuacion >= 60;  // true
let perfecto = puntuacion === 100; // false

console.log(typeof aprobado); // "boolean"

Undefined

El valor undefined indica que una variable ha sido declarada pero no se le ha asignado ningún valor:

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

También obtenemos undefined cuando accedemos a propiedades que no existen:

let usuario = { nombre: "Pedro" };
console.log(usuario.edad); // undefined

Null

El valor null representa la ausencia intencional de valor. A diferencia de undefined, null se asigna explícitamente para indicar "sin valor":

let resultado = null; // Intencionalmente vacío
let datos = null;     // Se asignará valor más tarde

console.log(typeof null); // "object" (peculiaridad histórica de JavaScript)

La diferencia entre null y undefined es sutil pero importante:

let sinAsignar;           // undefined (no se asignó valor)
let intencionadamenteVacio = null; // null (se asignó "sin valor")

console.log(sinAsignar == null);           // true
console.log(intencionadamenteVacio == undefined); // true
console.log(sinAsignar === null);          // false
console.log(intencionadamenteVacio === undefined); // false

Symbol

El tipo Symbol representa identificadores únicos. Cada símbolo creado es diferente a todos los demás, incluso si tienen la misma descripción:

let simbolo1 = Symbol("descripcion");
let simbolo2 = Symbol("descripcion");

console.log(simbolo1 === simbolo2); // false
console.log(typeof simbolo1);       // "symbol"

Los símbolos son útiles para crear propiedades privadas en objetos:

const ID = Symbol("id");
let usuario = {
    nombre: "Laura",
    [ID]: 12345 // Propiedad con clave símbolo
};

console.log(usuario[ID]); // 12345

BigInt

El tipo BigInt permite trabajar con números enteros de precisión arbitraria, superando las limitaciones del tipo number:

let numeroGrande = 1234567890123456789012345678901234567890n;
let otroBigInt = BigInt("987654321098765432109876543210");

console.log(typeof numeroGrande); // "bigint"

Los BigInt requieren el sufijo n o la función BigInt() para su creación:

let normal = 123;
let grande = 123n;

// console.log(normal + grande); // Error: no se pueden mezclar tipos
console.log(normal + Number(grande)); // 246
console.log(BigInt(normal) + grande);  // 246n

Verificación de tipos

Para determinar el tipo de una variable, utilizamos el operador typeof:

console.log(typeof 42);          // "number"
console.log(typeof "texto");     // "string"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object" (caso especial)
console.log(typeof Symbol());    // "symbol"
console.log(typeof 123n);        // "bigint"

Esta información sobre tipos primitivos es fundamental para entender cómo JavaScript maneja los datos y será la base para operaciones más complejas que veremos en las siguientes lecciones del curso.

Conversión de tipos

La conversión de tipos en JavaScript es el proceso de transformar un valor de un tipo de dato a otro. Este mecanismo es fundamental para el funcionamiento del lenguaje, ya que permite que operaciones entre diferentes tipos sean posibles. JavaScript realiza estas conversiones de dos formas: automáticamente (coerción implícita) o cuando nosotros lo solicitamos explícitamente.

Conversión implícita (coerción)

JavaScript realiza conversiones automáticas cuando detecta que se intenta operar con tipos incompatibles. Este comportamiento puede ser útil pero también puede generar resultados inesperados si no lo comprendemos bien:

let resultado = "5" + 3;    // "53" (number se convierte a string)
let suma = "5" - 3;         // 2 (string se convierte a number)
let multiplicacion = "4" * 2; // 8 (string se convierte a number)

En operaciones aritméticas (excepto suma), JavaScript convierte strings a numbers:

console.log("10" - "3");    // 7
console.log("15" / "3");    // 5
console.log("8" % "3");     // 2

Sin embargo, el operador de suma tiene un comportamiento especial, ya que también se usa para concatenar strings:

console.log(5 + "años");    // "5años"
console.log("Tengo " + 25); // "Tengo 25"
console.log(10 + 5 + "€");  // "15€"
console.log("€" + 10 + 5);  // "€105"

Conversión a string

Para convertir explícitamente cualquier valor a string, disponemos de varias opciones. La más recomendada es usar String():

let numero = 42;
let booleano = true;
let nulo = null;

console.log(String(numero));    // "42"
console.log(String(booleano));  // "true"
console.log(String(nulo));      // "null"

También podemos usar el método .toString(), aunque tiene limitaciones con null y undefined:

let edad = 25;
let activo = false;

console.log(edad.toString());   // "25"
console.log(activo.toString()); // "false"

// let vacio = null;
// console.log(vacio.toString()); // Error: Cannot read property 'toString' of null

Una técnica común es concatenar con string vacío:

let puntuacion = 95;
let convertido = puntuacion + "";
console.log(convertido);        // "95"
console.log(typeof convertido); // "string"

Conversión a number

Para convertir valores a números, la función Number() es la opción más directa y predecible:

console.log(Number("123"));     // 123
console.log(Number("45.67"));   // 45.67
console.log(Number(true));      // 1
console.log(Number(false));     // 0
console.log(Number(null));      // 0
console.log(Number(undefined)); // NaN

Para strings que no representan números válidos, Number() devuelve NaN:

console.log(Number("abc"));     // NaN
console.log(Number("123abc"));  // NaN
console.log(Number(""));        // 0 (string vacío se convierte a 0)
console.log(Number("   "));     // 0 (espacios en blanco se convierten a 0)

Las funciones parseInt() y parseFloat() son útiles cuando necesitamos extraer números de strings que contienen otros caracteres:

console.log(parseInt("123abc"));    // 123
console.log(parseInt("45.67"));     // 45 (ignora decimales)
console.log(parseFloat("45.67abc")); // 45.67
console.log(parseFloat("precio: 25")); // NaN (no empieza por número)

parseInt() puede trabajar con diferentes bases numéricas:

console.log(parseInt("1010", 2));   // 10 (binario)
console.log(parseInt("FF", 16));    // 255 (hexadecimal)
console.log(parseInt("77", 8));     // 63 (octal)

Conversión a boolean

La conversión a boolean sigue reglas claras sobre qué valores se consideran "falsy" (falsos) y "truthy" (verdaderos):

// Valores falsy (se convierten a false)
console.log(Boolean(0));           // false
console.log(Boolean(-0));          // false
console.log(Boolean(NaN));         // false
console.log(Boolean(""));          // false
console.log(Boolean(null));        // false
console.log(Boolean(undefined));   // false
console.log(Boolean(false));       // false

Todos los demás valores se consideran truthy:

console.log(Boolean(1));           // true
console.log(Boolean(-5));          // true
console.log(Boolean("texto"));     // true
console.log(Boolean("0"));         // true (string no vacío)
console.log(Boolean([]));          // true (array vacío)
console.log(Boolean({}));          // true (objeto vacío)

Una técnica común para convertir a boolean es usar el operador de negación doble:

let valor = "hola";
let esVerdadero = !!valor;  // true
console.log(typeof esVerdadero); // "boolean"

// Equivalente a:
let esVerdadero2 = Boolean(valor);

Verificación antes de convertir

Para evitar errores o resultados inesperados, es recomendable verificar los valores antes de realizar conversiones:

function convertirANumero(valor) {
    if (typeof valor === "string" && valor.trim() !== "") {
        let numero = Number(valor);
        return isNaN(numero) ? 0 : numero;
    }
    return Number(valor);
}

console.log(convertirANumero("123"));   // 123
console.log(convertirANumero("abc"));   // 0
console.log(convertirANumero(""));      // 0

Las funciones isNaN() e **isFinite()** son útiles para validar resultados numéricos:

let resultado = Number("abc123");
console.log(isNaN(resultado));      // true (no es un número válido)

let division = 10 / 0;
console.log(isFinite(division));    // false (Infinity no es finito)

Comparaciones y conversiones

JavaScript realiza conversiones automáticas en comparaciones, lo que puede generar comportamientos confusos. Por eso se recomienda usar operadores de comparación estricta:

// Comparación con conversión (==)
console.log(0 == false);        // true
console.log("" == false);       // true
console.log("0" == false);      // true

// Comparación estricta (===)
console.log(0 === false);       // false
console.log("" === false);      // false
console.log("0" === false);     // false

Entender la conversión de tipos es esencial para escribir JavaScript robusto y predecible. Aunque las conversiones implícitas pueden ser útiles, el uso de conversiones explícitas hace que nuestro código sea más claro y menos propenso a errores inesperados.