Categoría: Otros

Un array es una estructura de datos que permite almacenar y organizar múltiples elementos relacionados bajo un solo nombre. Los elementos dentro de un array pueden ser de cualquier tipo de dato, como por ejemplo números, cadenas, objetos y funciones. Los arrays son una parte esencial de la programación, ya que permiten manejar y manipular colecciones de datos de manera eficiente.

Elementos e índices

Podemos imaginar un array como una caja con compartimentos numerados, donde cada compartimento puede contener un valor. Cada valor se llama «elemento» y se almacena en una posición específica identificada con un «índice». Los índices comienzan desde 0, lo que significa que el primer elemento tiene un índice de 0, el segundo tiene un índice de 1, y así sucesivamente.

Creación de arrays

Podemos crear un array utilizando la sintaxis de corchetes [], dentro de los cuales colocamos los elementos separados por comas:

let numeros = [1, 2, 3, 4, 5];
let colores = ["rojo", "verde", "azul"];
let mixto = [10, "texto", true, null, { nombre: "Juan" }];

Acceso a elementos

Podemos acceder a los elementos de un array utilizando su índice, que comienza desde 0. Por ejemplo, con el código que mostramos a continuación, en el array frutas, el elemento en el índice 0 es «manzana», el elemento en el índice 1 es «pera», y así sucesivamente:

let frutas = ["manzana", "pera", "naranja", "sandía"];

console.log(frutas[0]); // Salida: "manzana"
console.log(frutas[1]); // Salida: "pera"
console.log(frutas[2]); // Salida: "naranja"

Propiedad length

Cada array tiene una propiedad length que indica la cantidad de elementos que contiene:

let colores = ["rojo", "verde", "azul"];

console.log(colores.length); // Salida: 3

Modificación de elementos

Podemos modificar elementos de un array asignando nuevos valores a sus índices. Por ejemplo, a continuación mostramos el código necesario para cambiar el valor del segundo elemento en el array colores:

let colores = ["rojo", "verde", "azul"];

colores[1] = "amarillo";

console.log(colores); // Salida: ["rojo", "amarillo", "azul"]

Métodos de arrays

JavaScript proporciona una gran variedad de métodos incorporados para trabajar con arrays. Estos métodos nos permiten realizar operaciones como añadir, eliminar, filtrar, mapear y más, de manera muy eficiente y legible. A continuación enumeramos algunos de los métodos más importantes.

push() y pop()

• push(): Agrega elementos al final del arreglo.
• pop(): Elimina el último elemento del arreglo.

let colores = ["rojo", "verde"];

colores.push("azul");
console.log(colores); // Salida: ["rojo", "verde", "azul"]

colores.pop();
console.log(colores); // Salida: ["rojo", "verde"]

shift() y unshift()

• unshift(): Agrega elementos al inicio del arreglo.
• shift(): Elimina el primer elemento del arreglo.

let numeros = [2, 3, 4];

numeros.unshift(1);
console.log(numeros); // Salida: [1, 2, 3, 4]

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

splice()

• Permite agregar, eliminar o reemplazar elementos en una posición específica.

let numeros = [1, 2, 3, 4, 5];

// Reemplaza 2 y 3 con 6 y 7
numeros.splice(1, 2, 6, 7);

console.log(numeros); // Salida: [1, 6, 7, 4, 5]

slice()

• Retorna una copia superficial de una porción del arreglo, sin modificar el arreglo original.

let colores = ["rojo", "verde", "azul"];

let subColores = colores.slice(1, 3);

console.log(subColores); // Salida: ["verde", "azul"]

Iteración a través de arrays

Podemos recorrer elementos de un array utilizando bucles como for, while, forEach, for...of, etc.:

let numeros = [1, 2, 3, 4, 5];
for (let i = 0; i < numeros.length; i++) {
  console.log(numeros[i]); // Imprime cada número
}

let colores = ["rojo", "verde", "azul"];
colores.forEach(function(color) {
  console.log(color); // Imprime cada color
});

Métodos de búsqueda y manipulación

indexOf() y lastIndexOf()

• indexOf(): Encuentra la primera posición de un elemento en el arreglo.
• lastIndexOf(): Encuentra la última posición de un elemento en el arreglo.

let numeros = [1, 2, 3, 2, 4, 5];

console.log(numeros.indexOf(2));      // Salida: 1
console.log(numeros.lastIndexOf(2));  // Salida: 3

includes()

• Verifica si un elemento existe en el arreglo.

let colores = ["rojo", "verde", "azul"];

console.log(colores.includes("verde")); // Salida: true
console.log(colores.includes("amarillo")); // Salida: false

join()

• Combina todos los elementos de un array en una cadena utilizando un separador:

let colores = ["rojo", "verde", "azul"];

let cadena = colores.join(", ");

console.log(cadena); // Salida: "rojo, verde, azul"

concat()

• Combina dos o más arreglos en uno nuevo.

let numeros = [1, 2, 3];
let otrosNumeros = [4, 5, 6];

let combinados = numeros.concat(otrosNumeros);

console.log(combinados); // Salida: [1, 2, 3, 4, 5, 6]

Ordenamiento de arrays

sort()

• Ordena los elementos de un arreglo en su lugar, utilizando la conversión a cadenas y la comparación de Unicode.

let frutas = ["naranja", "manzana", "plátano"];

frutas.sort();

console.log(frutas); // Salida: ["manzana", "naranja", "plátano"]

reverse()

• Invierte el orden de los elementos en el arreglo.

let numeros = [1, 2, 3, 4, 5];

numeros.reverse();

console.log(numeros); // Salida: [5, 4, 3, 2, 1]

Creación y manipulación funcional

map()

• Crea un nuevo arreglo con los resultados de aplicar una función a cada elemento del arreglo original.

let numeros = [1, 2, 3];

let duplicados = numeros.map(function(numero) {
  return numero * 2;
});

console.log(duplicados); // Salida: [2, 4, 6]

filter()

• Crea un nuevo arreglo con todos los elementos que pasen una prueba (función proporcionada).

let numeros = [1, 2, 3, 4, 5, 6];

let pares = numeros.filter(function(numero) {
  return numero % 2 === 0;
});

console.log(pares); // Salida: [2, 4, 6]

reduce()

• Aplica una función a un acumulador y a cada elemento en el arreglo (de izquierda a derecha) para reducirlo a un solo valor.

let numeros = [1, 2, 3, 4, 5];

let suma = numeros.reduce(function(acumulador, numero) {
  return acumulador + numero;
}, 0);

console.log(suma); // Salida: 15

Arreglos multidimensionales

Los arrays en JavaScript pueden contener otros arrays, lo que se conoce como arrays multidimensionales. Esto es útil cuando necesitamos trabajar con estructuras de datos más complejas, como por ejemplo matrices:

let matriz = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

console.log(matriz[1][2]); // Salida: 6

Copia de arrays

La asignación directa de un array a otra variable simplemente copia la referencia, no los valores. Para crear una copia independiente, podemos utilizar el operador de propagación ..., el método slice() o concat().

let original = [1, 2, 3];
let copiaSpread = [...original];
let copiaSlice = original.slice();
let copiaConcat = original.concat();

console.log(copiaSpread); // [1, 2, 3]
console.log(copiaSlice);  // [1, 2, 3]
console.log(copiaConcat); // [1, 2, 3]

Consideraciones adicionales

• Los arrays en JavaScript son dinámicos, lo que significa que puedes agregar o eliminar elementos en cualquier momento.
• Los índices negativos no están permitidos en arrays (a diferencia de algunos lenguajes de programación como python).

Conclusión

Los arreglos en JavaScript son herramientas fundamentales para trabajar con colecciones de datos de manera organizada y eficiente. Puedes acceder, modificar y utilizar los elementos de un arreglo a través de índices, y aprovechar los métodos integrados para realizar operaciones comunes. Los arreglos te permiten gestionar datos de manera más estructurada, lo que es esencial para desarrollar aplicaciones más robustas y funcionales.

Test

Comprueba tus conocimientos con este test sobre arrays y otros conceptos relacionados con esta unidad.

Los bucles son estructuras fundamentales en la programación que permiten ejecutar repetidamente un bloque de código hasta que se cumpla una condición específica. En JavaScript, hay varias formas de implementar bucles, cada una con sus propias características y usos. A continuación mostramos explicaciones y ejemplos detallados para que puedas entender cómo funcionan los bucles en JavaScript.

Tipos de bucles en JavaScript

Bucle «while»

El bucle while repite un bloque de código mientras una condición especificada sea verdadera. La condición se verifica antes de cada iteración:

while (condición) {
  // Código a ejecutar en cada iteración
}

Por ejemplo:

let contador = 0;
while (contador < 5) {
  console.log(contador); // Imprime los números del 0 al 4
  contador++;
}

• Condición (contador < 5): La condición se verifica antes de cada iteración. Mientras contador sea menor que 5, el bucle continuará ejecutándose.
• Bloque de código: Dentro del bucle, se imprime el valor actual de contador y luego se incrementa en 1.

Bucle «do…while»

El bucle do...while es similar al while, pero garantiza que el bloque de código se ejecute al menos una vez, ya que la condición se verifica después de cada iteración:

do {
  // Código a ejecutar en cada iteración
} while (condición);

Por ejemplo:

let x = 0;
do {
  console.log(x); // Imprime 0 (al menos una vez)
  x++;
} while (x < 0);

• Bloque de código: Dentro del bucle, se imprime el valor actual de x y luego se incrementa en 1.
• Condición (x < 0): Después de cada iteración, se verifica la condición. Aunque x es 1 en la primera iteración y no cumple la condición, el bloque de código se ejecuta al menos una vez.

Bucle «for»

El bucle for es una estructura común utilizada para repetir un bloque de código un número específico de veces. Consiste en tres partes: la inicialización, la condición y la actualización:

for (inicialización; condición; actualización) {
  // Código a ejecutar en cada iteración
}

Por ejemplo:

for (let i = 0; i < 5; i++) {
  console.log(i); // Imprime los números del 0 al 4
}

• Inicialización (let i = 0): Se define una variable i e inicia a 0 antes de comenzar el bucle.
• Condición (i < 5): La condición se verifica antes de cada iteración. Mientras i sea menor que 5, el bucle continuará ejecutándose.
• Actualización (i++): Después de cada iteración, se incrementa el valor de i en 1.

Control de bucles

break

La sentencia break se utiliza para finalizar prematuramente un bucle antes de que se cumpla la condición. Por ejemplo, en el siguiente código, cuando i es igual a 5, se ejecuta break, lo que detiene el bucle for y sale del mismo:

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break; // Termina el bucle cuando i llega a 5
  }
  console.log(i); // Imprime los números del 0 al 4
}

continue

La sentencia continue se utiliza para saltar una iteración y continuar con la siguiente. Por ejemplo, en el siguiente código, cuando i es igual a 2, se ejecuta continue, lo que salta la iteración actual y pasa a la siguiente:

for (let i = 0; i < 5; i++) {
  if (i === 2) {
    continue; // Salta la iteración cuando i es 2
  }
  console.log(i); // Imprime los números 0, 1, 3, 4
}

Bucles anidados

Es posible anidar bucles dentro de otros bucles para realizar tareas más complejas. Los bucles anidados ejecutan el bucle interno completamente para cada iteración del bucle externo. Por ejemplo:

for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 2; j++) {
    console.log(i, j); // Imprime todas las combinaciones de i y j
  }
}

• El bucle exterior for itera tres veces (i = 0, 1, 2).
• Para cada iteración del bucle exterior, el bucle interior for se ejecuta dos veces (j = 0, 1).
• Se imprimen todas las combinaciones posibles de i y j.

Bucles con arrays y objetos

Podemos recorrer todos los elementos de una colección de datos usando un bucle «for» con un contador para incrementar el índice de cada elemento y la propiedad length para comprobar la cantidad total de elementos. Por ejemplo, en el siguiente código imprimimos todos los elementos del array frutas utilizando un bucle for:

let frutas = ["manzana", "banana", "naranja"];

for (let i = 0; i < frutas.length; i++) {
  console.log(frutas[i]); // Imprime los elementos del array
}

• El bucle for itera a través de los índices del array frutas.
• Se utiliza la propiedad length del array para definir la condición de terminación del bucle.
• frutas[i] accede al elemento en el índice i y lo imprime en cada iteración.

Sin embargo, JavaScript nos proporciona otro tipo de bucles que resultan más adecuados para iterar sobre colecciones de datos. Tanto el bucle for...of como el bucle for...in tienen ventajas y casos de uso específicos en comparación con un bucle for tradicional en JavaScript. A continuación añadimos una explicación de cuándo y por qué podríamos preferir usar for...of o for...in en lugar de un bucle for estándar.

Bucle «for…of»

Este tipo de bucle está diseñado específicamente para iterar sobre elementos de colecciones iterables, como arrays y cadenas. A continuación enumeramos algunas razones para usar for...of:

1. Sintaxis más clara: La sintaxis es más sencilla y fácil de entender que un bucle for tradicional.
2. No necesita utilizar índices: No es necesario utilizar un contador de índices separado, lo que reduce los errores potenciales.
3. Iteración en orden: Itera sobre los elementos en el orden en que aparecen en la colección, lo que lo hace especialmente útil para trabajar con arrays.
4. Soporte para iterables: Podemos usarlo con cualquier objeto iterable, no solo con arrays. Esto incluye cadenas, mapas y conjuntos.

let colores = ["rojo", "verde", "azul"];

for (let color of colores) {
  console.log(color); // Imprime los elementos del array
}

Bucle «for…in»

Este bucle está diseñado para trabajar con objetos, ya que nos aporta las siguientes ventajas:

1. Iteración sobre las propiedades de un objeto: Nos permite recorrer todas las propiedades de un objeto.
2. Acceso a las propiedades de objetos genéricos: Nos permite trabajar con objetos genéricos cuyas propiedades no son conocidas de antemano.
3. Manipulación de propiedades: Podemos modificar o realizar operaciones en las propiedades del objeto mientras iteramos sobre ellas.

const persona = {
  nombre: 'Alicia',
  edad: 30,
  trabajo: 'Ingeniera'
};

for (const propiedad in persona) {
  console.log(`${propiedad}: ${persona[propiedad]}`); // Imprime las propiedades y los valores
}

En resumen, el bucle for...in es adecuado cuando necesitamos iterar sobre las propiedades de un objeto, especialmente si las propiedades son dinámicas o desconocidas de antemano.

Bucle «forEach»

Los bucles forEach nos proporcionan una forma aún más legible y adecuada para iterar a través de los elementos de un array en JavaScript. En el siguiente ejemplo podemos apreciar la diferencia respecto a un bucle for tradicional:

let frutas = ["manzana", "banana", "naranja"];

for (let indice = 0; indice < frutas.length; indice++) {
  console.log(`Índice ${indice}: ${frutas[indice]}`); // Imprime los elementos del array
}

frutas.forEach(function(fruta, indice) {
  console.log(`Índice ${indice}: ${fruta}`); // Imprime los elementos del array
});

// Salida:
// Índice 0: manzana
// Índice 1: banana
// Índice 2: naranja

Estas son algunas de las razones por las cuales podríamos preferir usar el bucle forEach en lugar de un bucle for tradicional:

1. Enfocado a la iteración: El bucle forEach está diseñado específicamente para la iteración sobre los elementos de una colección (por ejemplo, un array). Esto hace que el código sea más expresivo y se centre en la tarea de iterar, en lugar de en la manipulación de índices.
2. Menos propenso a errores: Al eliminar la necesidad de rastrear índices manualmente, reducimos la probabilidad de errores comunes, como errores de límites de índice y problemas de incremento/decremento incorrecto.
3. No se necesita lógica de salida: En un bucle for tradicional debemos incluir lógica adicional para controlar la salida del bucle. En un bucle forEach esta funcionalidad se incluye de manera automática.

En general, los bucles forEach nos proporcionarán una sintaxis más clara y concisa, ya que no necesitamos inicializar y actualizar manualmente un contador de índices, ni tampoco debemos incluir una lógica de salida del bucle, lo que puede hacer que el código sea más legible y menos propenso a errores.

Uso de funciones flecha en bucles «forEach»

En lugar de utilizar una función anónima tradicional, también podemos utilizar funciones flecha (=>) para hacer el código más conciso, como se observa en el siguiente ejemplo:

let frutas = ["manzana", "banana", "naranja"];

frutas.forEach((fruta, indice) => {
  console.log(`Índice ${indice}: ${fruta}`);
});

Modificando elementos en bucles «forEach»

No sólo podemos usar un bucle forEach para consultar todos los elementos de un array, sino que también podemos realizar modificaciones sobre cada uno de ellos. Bastará con utilizar el índice para acceder a los valores correspondientes y realizar las operaciones oportunas, como se observa en el siguiente ejemplo:

let numeros = [1, 2, 3, 4, 5];

numeros.forEach(function(numero, indice, array) {
  array[indice] = numero * 2;
});

console.log(numeros); // Salida: [2, 4, 6, 8, 10]

Limitaciones del bucle «forEach»

Si bien el bucle forEach tiene muchas ventajas, es importante señalar que también tiene algunas limitaciones en comparación con un bucle for tradicional. Por ejemplo, no podemos realizar saltos anticipados utilizando break o continue directamente en un bucle forEach. A continuación mostraremos posibles alternativas para conseguir el mismo comportamiento.

Utilizando return dentro de un bucle «forEach»

En el siguiente bucle for se puede observar el uso de la instrucción continue para realizar un salto condicional cuando se encuentra cierto valor:

const array = [1, 2, 3, 4, 5];

for (let i = 0; i < array.length; i++) {
  const item = array[i];

  if (item === 3) {
    console.log("Saltando a la siguiente iteración");
    continue; // Esto omite la ejecución de la iteración actual
  }

  console.log(item);
}
// Salida: 1 2 4 5

Aunque el bucle forEach no tiene un equivalente directo a la palabra clave continue, podemos lograr un comportamiento similar utilizando una estructura de control if para omitir la ejecución de ciertas iteraciones del bucle. En el siguiente ejemplo utilizamos return para salir anticipadamente de la iteración actual y continuar con la siguiente iteración cuando el valor del elemento es igual a 3:

const array = [1, 2, 3, 4, 5];

array.forEach(item => {
  if (item === 3) {
    console.log("Saltando esta iteración");
    return; // Esto omite la ejecución de la iteración actual, similar a un continue
  }

  console.log(item);
});
// Salida: 1 2 4 5

Debemos tener en cuenta que el uso de return dentro de una función forEach simplemente finaliza la función de la iteración actual, lo que resulta en un efecto similar a continue. Sin embargo, esta no es una característica específica de forEach, sino una aplicación de cómo funciona return en funciones en general.

Usando un bucle «some» en vez de «forEach»

A continuación mostramos un bucle for donde se puede observar el uso de la instrucción break para finalizar el bucle cuando se encuentra el valor deseado:

const array = [1, 2, 3, 4, 5];

for (let i = 0; i < array.length; i++) {
  const item = array[i];

  if (item === 3) {
    console.log("Saltando el bucle");
    break; // Esto finaliza el bucle for
  }

  console.log(item);
}
// Salida: 1 2

Si queremos salir anticipadamente de un bucle cuando estamos iterando sobre un array, podemos usar el método some() para lograr el comportamiento deseado. En el siguiente ejemplo, si se encuentra un valor igual a 3, se muestra un mensaje y se devuelve true, lo que finaliza el bucle. Si no se encuentra el valor, la iteración continúa:

const array = [1, 2, 3, 4, 5];

array.some(item => {
  if (item === 3) {
    console.log("Saliendo del bucle");
    return true; // Esto finaliza el bucle
  }

  console.log(item);
  return false; // Continúa iterando
});
// Salida: 1 2

Usos comunes de forEach

• Realizar operaciones en cada elemento de un array.
• Imprimir elementos de un array con formato personalizado.
• Invocar llamadas a funciones para cada elemento de un array.

En resumen, el bucle forEach es una herramienta útil para iterar a través de elementos de un array de manera más simple y legible. Resulta especialmente útil para realizar operaciones en cada elemento sin necesidad de un contador de índice. Sin embargo, si necesitamos más control sobre la iteración, como detenerla anticipadamente o realizar modificaciones complejas en el array, es posible que prefiramos utilizar otros tipos de bucles. La elección entre usar un bucle tradicional y un bucle forEach dependerá del contexto y de las necesidades específicas en cada situación.

Test

Comprueba tus conocimientos con este test sobre bucles y otros conceptos relacionados con esta unidad.