Arreglos (Arrays) - Tutorial de Introducción a la Programación

Resumen Rápido

Los arreglos almacenan listas ordenadas accesibles por índice (comenzando en 0). Tienen métodos incorporados para agregar, eliminar, buscar y transformar datos. Los arreglos son una de las estructuras de datos más comúnmente usadas en programación.

¿Qué es un Arreglo?

Un arreglo es una colección ordenada de valores. Cada valor tiene un índice (posición) que comienza desde 0.

const fruits = ["apple", "banana", "cherry"];
//    index:      0         1         2

Creando Arreglos

const empty = [];
const numbers = [1, 2, 3, 4, 5];
const mixed = ["text", 42, true, null];
const nested = [[1, 2], [3, 4]]; // 2D array

Accediendo a Elementos

const colors = ["red", "green", "blue"];
colors[0];  // "red" (first element)
colors[2];  // "blue" (third element)
colors[-1]; // undefined (no negative indices in JS)
colors[99]; // undefined (out of bounds)

Propiedades del Arreglo

const items = [1, 2, 3];
items.length; // 3 (number of elements)

Métodos Comunes de Arreglos

Agregar/Eliminar:

const arr = [1, 2, 3];
arr.push(4);      // Add to end → [1, 2, 3, 4]
arr.pop();        // Remove from end → [1, 2, 3]
arr.unshift(0);   // Add to start → [0, 1, 2, 3]
arr.shift();      // Remove from start → [1, 2, 3]

Buscar:

const nums = [1, 2, 3, 4, 5];
nums.includes(3);    // true
nums.indexOf(3);     // 2 (index of first match)
nums.find(n => n > 3); // 4 (first match)

Transformar:

const nums = [1, 2, 3];
nums.map(n => n * 2);      // [2, 4, 6]
nums.filter(n => n > 1);   // [2, 3]
nums.reduce((sum, n) => sum + n, 0); // 6

Otros Métodos Útiles:

[1, 2].concat([3, 4]);   // [1, 2, 3, 4]
[3, 1, 2].sort();        // [1, 2, 3]
[1, 2, 3].reverse();     // [3, 2, 1]
[1, 2, 3].join("-");     // "1-2-3"
"a-b-c".split("-");      // ["a", "b", "c"]

Pruébalo Tú Mismo

Aquí tienes un ejemplo práctico que puedes probar. Copia este código y ejecútalo en la consola de tu navegador (presiona F12 para abrir las herramientas de desarrollo) o en el Playground de Código.

// Creating arrays
const fruits = ["apple", "banana", "cherry"];
const numbers = [10, 20, 30, 40, 50];

// Accessing by index (starts at 0)
console.log(fruits[0]);    // "apple"
console.log(fruits[2]);    // "cherry"
console.log(fruits.length); // 3

// Modifying arrays
fruits.push("date");        // Add to end
console.log(fruits);        // ["apple", "banana", "cherry", "date"]

fruits.pop();               // Remove from end
console.log(fruits);        // ["apple", "banana", "cherry"]

// Useful array methods
const doubled = numbers.map(n => n * 2);
console.log(doubled); // [20, 40, 60, 80, 100]

const bigNumbers = numbers.filter(n => n > 25);
console.log(bigNumbers); // [30, 40, 50]

const total = numbers.reduce((sum, n) => sum + n, 0);
console.log(total); // 150

// Checking if array contains a value
console.log(fruits.includes("banana")); // true
console.log(fruits.indexOf("cherry"));  // 2

// Combining arrays
const moreFruits = ["elderberry", "fig"];
const allFruits = fruits.concat(moreFruits);
// or: const allFruits = [...fruits, ...moreFruits];

Puntos Clave

✓Almacena listas ordenadas de datos que pueden crecer o reducirse.
✓Practica con ejemplos de código reales para solidificar tu comprensión
✓Este concepto construye la base para temas más avanzados