Comprendiendo los Tipos y Estructuras de Datos en Programación con JavaScript

JavaScript Logo

En el desarrollo de software, los tipos de datos y las estructuras de datos son elementos esenciales que todo programador debe dominar. Estos conceptos no solo son la base de cualquier aplicación, sino que también definen cómo se manejan y manipulan los datos en un programa. En este post, exploraremos qué son los tipos y las estructuras de datos usando JavaScript, uno de los lenguajes de programación más populares.

Tipos de Datos en JavaScript

JavaScript es un lenguaje de tipado dinámico, lo que significa que no necesitas declarar el tipo de una variable cuando la defines. Sin embargo, comprender los tipos de datos disponibles es crucial para evitar errores y escribir código claro y eficiente.

1. Tipos Primitivos

Los tipos primitivos son los bloques de construcción más básicos en JavaScript. Aquí algunos ejemplos:

number: Representa tanto números enteros como decimales.

let edad = 25;
 
let precio = 14.50;

Nota: La palabra reservada let se utiliza para declarar una variable en JavaScript, en este caso estamos declarando una variable llamada edad que almacenará el número entero 25 y otra llamada precio que almacenará el número decimal o flotante 14.50. Pero podemos omitir esto por ahora. Hablaremos sobre variables más adelante.

string: Representa cadenas de texto.

let nombre = "Pedro";

boolean: Representa valores de verdad: true o false.

let esProgramador = true;

null: Representa la ausencia de un valor intencional.

let valorNulo = null;

undefined: Indica que una variable ha sido declarada pero aún no tiene un valor asignado.

let sinDefinir = undefined;
 
// Podemos omitir la asignación de undefined y el valor de sinDefinir será exactamente el mismo
let sinDefinir

symbol: Introducido en ES6, los símbolos son valores únicos y no modificables que se utilizan como identificadores.

let id = Symbol("id");

2. Tipos Complejos

Además de los tipos primitivos, JavaScript también maneja tipos complejos que permiten trabajar con estructuras de datos más avanzadas.

object: Un tipo que permite almacenar colecciones de datos en forma de pares clave-valor.

let persona = {
  nombre: "Pedro",
  edad: 25,
  esProgramador: true
};

array: Es un tipo especial de objeto que almacena elementos en una colección indexada. Cada elementro dentro de un array posee un índice, en el caso de JavaScript, empezando por 0.

let numeros = [1, 2, 3, 4, 5];
 
// Para acceder al primer elemento de este array lo haríamos de la siguiente manera
let primerElemento = numeros[0] // Esto daría como resultado el valor del primer elemento que en este caso es 1.

3. Funciones y Tipos Personalizados

En JavaScript, las funciones también son un tipo de datos. Pueden ser tratadas como valores y se pueden asignar a variables, pasar como argumentos y retornar desde otras funciones.

function saludar(nombre) {
  return `Hola, ${nombre}`;
}
 
let mensaje = saludar("Pedro"); // Esto daría como resultado Hola, Pedro.

Además, puedes definir tipos personalizados utilizando constructores o clases (introducidas en ES6).

class Persona {
  constructor(nombre, edad) {
    this.nombre = nombre;
    this.edad = edad;
  }
 
  saludar() {
    return `Hola, soy ${this.nombre} y tengo ${this.edad} años.`;
  }
}
 
let usuario = new Persona("Pedro", 25);
 
usuario.saludar() // Esto daría como resultado Hola, soy Pedro y tengo 25 años;

Estructuras de Datos en JavaScript

Las estructuras de datos son formas organizadas de almacenar y gestionar datos en un programa. A continuación, exploraremos algunas de las estructuras de datos más comunes y cómo se implementan en JavaScript.

1. Arreglos (Arrays)

Como vimos anteriormente, los arrays o arreglos son un tipo de dato complejo y son una de las estructuras de datos más comunes. Permiten almacenar múltiples valores en una sola variable.

let nombres = ["Pedro", "Juan", "Camila", "Natalia"];

Con los arrays, puedes realizar operaciones como agregar, eliminar y recorrer elementos pero esto lo veremos en un post dedicado exclusivamente a esto.

Aclaración: Las siguientes son estructuras de datos un poco más complejas si recién estás comenzando a programar. No te desanimes si no entiendes ahora lo que hace el siguiente código ya que no es necesario saber esto cuando uno está comenzando, con el tiempo irás logrando adquirir más y más conceptos.

2. Listas Enlazadas (Linked Lists)

Aunque no están directamente soportadas como una estructura de datos predefinida en JavaScript, las listas enlazadas se pueden implementar usando funciones constructoras o clases.

class Nodo {
  constructor(valor) {
    this.valor = valor;
    this.siguiente = null;
  }
}
 
class ListaEnlazada {
  constructor() {
    this.cabeza = null;
  }
 
  agregar(valor) {
    let nuevoNodo = new Nodo(valor);
    if (!this.cabeza) {
      this.cabeza = nuevoNodo;
    } else {
      let actual = this.cabeza;
      while (actual.siguiente) {
        actual = actual.siguiente;
      }
      actual.siguiente = nuevoNodo;
    }
  }
}
 
let lista = new ListaEnlazada();
lista.agregar(10);
lista.agregar(20);

3. Pilas (Stacks) y Colas (Queues)

Las pilas y colas son estructuras de datos lineales que permiten gestionar colecciones de elementos de manera particular.

Pilas (Stacks): Siguen el principio LIFO (Last In, First Out). El último elemento agregado es el primero en salir.

class Pila {
  constructor() {
    this.elementos = [];
  }
 
  push(elemento) {
    this.elementos.push(elemento);
  }
 
  pop() {
    return this.elementos.pop();
  }
}
 
let pila = new Pila();
pila.push(1);
pila.push(2);
let ultimo = pila.pop(); // Devuelve 2

Nota: push añade un nuevo elemento al final del array elementos mientras que pop remueve el último elemento de dicho array.

Colas (Queues): Siguen el principio FIFO (First In, First Out). El primer elemento agregado es el primero en salir.

class Cola {
  constructor() {
    this.elementos = [];
  }
 
  enqueue(elemento) {
    this.elementos.push(elemento);
  }
 
  dequeue() {
    return this.elementos.shift();
  }
}
 
let cola = new Cola();
cola.enqueue(1);
cola.enqueue(2);
let primero = cola.dequeue(); // Devuelve 1

Nota: shift devuelve el primer elemento del array elementos `y lo elimina de dicho array.

4. Mapas y Conjuntos (Maps and Sets)

Mapas (Maps): Son estructuras que permiten almacenar pares clave-valor, con claves que pueden ser de cualquier tipo.

let mapa = new Map();
mapa.set("uno", 1);
mapa.set("dos", 2);
let valor = mapa.get("uno"); // Devuelve 1

Conjuntos (Sets): Almacenan valores únicos, eliminando automáticamente los duplicados.

let conjunto = new Set();
conjunto.add(1);
conjunto.add(2);
conjunto.add(2); // No se agregará el 2 otra vez

Conclusión

Comprender los tipos y las estructuras de datos es esencial para escribir código efectivo y eficiente. JavaScript, aunque es un lenguaje de tipado dinámico, ofrece una amplia gama de tipos y estructuras de datos que te permiten manejar y organizar información de manera efectiva. Ya sea que estés manipulando datos simples o creando estructuras complejas, dominar estos conceptos te permitirá desarrollar aplicaciones más robustas y escalables.

¡Espero que esta guía te haya ayudado a entender mejor estos fundamentos de programación en JavaScript! Si tienes alguna pregunta o sugerencia, no dudes en escribirme!