1. Conceptos

1.1. Definición

Un arreglo es una colección de datos, donde cada dato se conoce como un elemento. Un arreglo puede contener elementos de cualquier tipo.

1.2. Usos

• Los arreglos permiten almacenar múltiples valores en una sola variable y acceder a ellos mediante el nombre de la variable.
• Cada elemento en un arreglo tiene su propio ID (índice) para facilitar su acceso.
• Son útiles para manejar múltiples datos, agrupándolos en una sola variable.

1.3. Sintaxis

// Crear un arreglo vacío
let arreglo = [];
// Definir un arreglo no vacío
let nombres = ['Juan', 'María', 'Pedro'];
// O usar new Array
const arreglo2 = new Array(1, 4, 6, 7);

Los elementos del arreglo se definen entre corchetes [] y se separan por comas.

2. Acceso a Elementos

Se accede a los elementos de un arreglo mediante su índice, que coimenza en 0.

arreglo[nuevoIndice] = valor;

3. Propiedad length

La propiedad length de un arreglo indica el número de elementos en el arreglo.

4. Operaciones con Arreglos

4.1. Adición

• push(): Agrega uno o más elementos al final del arreglo y devuelve la nueva longitud.
• unnshift(): Agrega uno o más elementos al inicio del arreglo y devuelve la nueva longitud.

Ejemplos:

let numeros = [0, 1, 2, 3];
numeros.push(4);
console.log(numeros); // [0, 1, 2, 3, 4]

numeros.push(...[7, 8]);
console.log(numeros); // [0, 1, 2, 3, 4, 7, 8]

let letras = ["a", "b", "c"];
letras.unshift("d");
console.log(letras); // ["d", "a", "b", "c"]

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let combinado = arr1.concat(arr2);

console.log(arr1); // [1, 2, 3]
console.log(combinado); // [1, 2, 3, 4, 5, 6]

4.2. Eliminación

• pop(): Elimina el último elemento del arreglo y lo devuelve.
• shift(): Elimina el primer elemento del arreglo y lo devuelve.
• splice(): Agrega o elimina elementos en cualquier posición del arreglo.

Ejepmlos:

let numeros = [1, 2, 3];
numeros.pop();
console.log(numeros); // [1, 2]

numeros.shift();
console.log(numeros); // [2, 3]

numeros.splice(2, 1); // Elimina 1 elemento desde el índice 2
console.log(numeros); // [1, 2, 4, 5]

4.3. Búsqueda

• indexOf(): Devuelve el índice del primer elemento que coincide con el valor especificado.
• includes(): Devuelve true si el arreglo contiene el valor especificado, de lo contrario false.
• slice(): Devuelve una copia de una parte del arreglo.

Ejemplos:

let array = ["a", "b", "c"];
let b = array[1];
console.log(b); // b

const index = array.indexOf("c");
console.log(index); // 2

const isInArray1 = array.includes("b"); // true
const isInArray2 = array.includes("d"); // false
console.log(isInArray1, isInArray2);

console.log(array.slice(1, 3)); // [b, c]
console.log(array.slice(1)); // [b, c, d]

4.4. Modificación

• splice(): Permite modificar el arreglo, eliminando y/o agregando elementos.

Ejemplo:

let a = [1, 2, 3, 4, 5];
a.splice(2, 1, 9);
console.log(a); // [1, 2, 9, 4, 5]

5. Recorrido de Arreglos

Para recorrer un arreglo, se puede usar un bucle for.

let colores = ["rojo", "verde", "azul"];
for (let i = 0; i < colores.length; i++) {
  console.log(colores[i]);
}

6. Búsqueda de Índice

Para buscar el índice de un elemento en un arreglo, se puede usar un bucle for y indexOf.

const arr = [11, 55, 22, 33, 44];

const num = +prompt("Ingrese el número a buscar");

let index = -1;

for (let i = 0; i < arr.length; i++) {
  if (arr[i] == num) {
    index = i;
    break;
  }
}

console.log(index);

if (index == -1) {
  console.log("El elemento no está en el arreglo");
} else {
  console.log("El elemento se encuentra en el índice: " + index);
}

7. Arreglos Bidimensionales

Un arreglo bidimensional es un arreglo de arreglos.

Ejemplo:

let matriz = [
  [100, 90, 96],
  [88, 99, 68],
  [92, 55, 98],
];

// Ejemplo de uso en GIS
let puntos = [
  [100, 150],
  [200, 250],
  [300, 350],
  [100, 150],
];

8. Creación de una Baraja de Cartas

Para crear una baraja de cartas, se pueden seguir estos pasos:

1. Definir los palos y las figuras.
2. Crear un arreglo para la baraja.
3. Llenar la baraja con los palos y figuras.
4. Agregar los comodines.

Ejemplo:

const palos = ["♠", "♥", "♦", "♣"];
const figuras = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"];

let baraja = [];

let indice = 0;
for (let i = 0; i < palos.length; i++) {
  for (let j = 0; j < figuras.length; j++) {
    baraja[indice] = palos[i] + figuras[j];
    indice++;
  }
}

console.log(baraja);

baraja.push("Comodín 1", "Comodín 2");