Estructura de datos en JavaScript

Las estructuras de datos constituyen la base fundamental para organizar y manipular información en cualquier aplicación JavaScript. Comprender cómo almacenar, acceder y modificar datos de manera eficiente es esencial para desarrollar código robusto y escalable.

JavaScript ofrece múltiples formas de estructurar datos, desde los tipos primitivos básicos hasta estructuras más complejas como objetos y arrays. Cada estructura tiene características específicas que la hacen más adecuada para diferentes escenarios de programación.

Tipos de datos primitivos

Los datos primitivos representan valores únicos e inmutables que sirven como bloques de construcción básicos. JavaScript incluye varios tipos primitivos fundamentales.

El tipo number maneja tanto números enteros como decimales en un formato unificado:

let edad = 25;
let precio = 19.99;
let temperatura = -5.2;

Las cadenas de texto (strings) almacenan secuencias de caracteres y admiten múltiples formas de declaración:

let nombre = "María";
let apellido = 'González';
let mensaje = `Hola, ${nombre} ${apellido}`;

Los valores booleanos representan estados de verdadero o falso, fundamentales para la lógica de control:

let esActivo = true;
let estaCompleto = false;

Arrays: colecciones ordenadas

Los arrays constituyen estructuras de datos ordenadas que permiten almacenar múltiples elementos bajo un único identificador. Cada elemento ocupa una posición específica identificada por un índice numérico.

let frutas = ["manzana", "banana", "naranja"];
let numeros = [1, 2, 3, 4, 5];
let mixto = ["texto", 42, true, null];

El acceso a elementos se realiza mediante la notación de corchetes, comenzando desde el índice 0:

console.log(frutas[0]); // "manzana"
console.log(frutas[2]); // "naranja"

Los arrays son mutables, permitiendo modificar su contenido después de la creación:

frutas[1] = "pera";
frutas.push("uva"); // Añade al final
frutas.unshift("kiwi"); // Añade al inicio

Objetos: estructuras clave-valor

Los objetos organizan datos mediante pares clave-valor, proporcionando una forma intuitiva de representar entidades del mundo real con sus propiedades y características.

let persona = {
    nombre: "Carlos",
    edad: 30,
    profesion: "desarrollador",
    activo: true
};

El acceso a propiedades puede realizarse mediante notación de punto o corchetes:

console.log(persona.nombre); // "Carlos"
console.log(persona["edad"]); // 30

Los objetos permiten modificación dinámica de propiedades:

persona.email = "carlos@email.com"; // Nueva propiedad
persona.edad = 31; // Modificar existente
delete persona.activo; // Eliminar propiedad

Estructuras anidadas

JavaScript permite crear estructuras complejas combinando arrays y objetos para representar datos jerárquicos y relacionales.

Un array de objetos resulta útil para colecciones de entidades similares:

let empleados = [
    { nombre: "Ana", departamento: "IT", salario: 45000 },
    { nombre: "Luis", departamento: "Marketing", salario: 38000 },
    { nombre: "Sofia", departamento: "IT", salario: 52000 }
];

Los objetos pueden contener arrays como propiedades para representar relaciones uno-a-muchos:

let empresa = {
    nombre: "TechCorp",
    fundacion: 2010,
    departamentos: ["IT", "Marketing", "Ventas"],
    empleados: empleados
};

Manipulación de datos

Las operaciones de manipulación permiten transformar y procesar estructuras de datos de manera eficiente. Los arrays ofrecen métodos específicos para diferentes tipos de operaciones.

El método map() transforma cada elemento aplicando una función:

let precios = [10, 20, 30, 40];
let preciosConIVA = precios.map(precio => precio * 1.21);
// [12.1, 24.2, 36.3, 48.4]

El método filter() selecciona elementos que cumplen una condición:

let empleadosIT = empleados.filter(emp => emp.departamento === "IT");

Para objetos, la iteración se realiza mediante métodos específicos:

// Obtener todas las claves
let claves = Object.keys(persona);

// Obtener todos los valores
let valores = Object.values(persona);

// Iterar sobre pares clave-valor
Object.entries(persona).forEach(([clave, valor]) => {
    console.log(`${clave}: ${valor}`);
});

Consideraciones de rendimiento

La elección de estructura impacta directamente en el rendimiento de la aplicación. Los arrays son eficientes para acceso secuencial y operaciones matemáticas, mientras que los objetos optimizan el acceso por clave.

Para búsquedas frecuentes por identificador, los objetos superan a los arrays:

// Menos eficiente para búsquedas
let usuariosArray = [
    { id: 1, nombre: "Ana" },
    { id: 2, nombre: "Luis" }
];

// Más eficiente para búsquedas por ID
let usuariosObjeto = {
    1: { nombre: "Ana" },
    2: { nombre: "Luis" }
};

La inmutabilidad puede mejorar la predictibilidad del código, especialmente en aplicaciones complejas:

// Crear nuevo array en lugar de modificar
let nuevasFrutas = [...frutas, "mango"];

// Crear nuevo objeto en lugar de modificar
let nuevaPersona = { ...persona, edad: persona.edad + 1 };