DEV Community: Alex Córdoba

Operadores no tan comunes de Rxjs

Alex Córdoba — Mon, 24 Apr 2023 22:20:14 +0000

Después de dar un vistazo a los operadores comunes en Rxjs, esta vez es el turno de algunos operadores que no son tan comunes, tal vez desconocidos por algunos devs, pero muy utiles a la hora de agregar un comportamiento a nuestros Observables.

first

El operador first es un operador de filtrado que emite solo el primer valor que se emite en la secuencia de entrada y luego completa la secuencia.
También es posible especificar una condición opcional para determinar el primero valor que se emite.

La forma general del operador first es la siguiente:

first(predicate?: function): Observable

El argumento predicate es una función que se usa para determinar el primero valor que se emite en la secuencia. Si no se proporciona ninguna función predicate el operador first emitirá el primero que se emita en la secuencia, teniendo el mismo comportamiento como si usáramos el operador take(1).

aqui hay un ejemplo:

import { interval } from 'rxjs'
import { first } from 'rxjs/operators';

const source = from([1, 2, 3, 4, 5]);

const example - source.pipe(
 first(x => x > 2)
);

example.subscribe(console.log) // salida: 3

En este ejemplo, creamos un Observable que emite los valores 1, 2, 3, 4, 5 y luego aplicamos el operador first con una función predicate que devuelve true para el primer valor que sea mayor que 2. El primer valor que se emite en la secuencia que satisface la condición es 3, por lo que esa es la salida del subscribe.

Es importante tener en cuenta que take completará la secuencia después de emitir el primer valor, por lo que cualquier valor adicional que se emita después del primero valor se descartará. Si no se emite ningún valor que satisfaga la condición, el Observable resultante no emitirá ningún valor.

takeWhile

El operador takeWhile es un operador de filtrado que toma los valores emitidos por un Observable hasta que se produce un valor que no satisface una condición especificada.

La forma general del operador takeWhile es la siguiente:

takeWhile(predicate?: function, inclusive?: boolean): Observable

El argumento predicate es una función que se utiliza para evaluar cada valor emitido por el Observable. Si el valor emitido satisface la condición especificada, se incluirá en el resultado. Si el valor no satisface la condición, la suscripción se completará y se dejará de emitir valores.

El argumento opcional inclusive se utiliza para incluir o excluir el valor que no cumple la condición especificada. Si inclusive es true, el valor que no cumple la condición se incluirá en la salida. Si inclusive es false el valor que no cumple la condición se excluye de la salida.

Por ejemplo:

import { of } from 'rxjs'
import { takeWhile } from 'rxjs/operators';

const source = of(1, 2, 3, 4, 5);

const example - source.pipe(
 takeWhile(x => x < 4)
);

example.subscribe(console.log) // salida: 1, 2, 3

En este ejemplo, creamos un Observable que emite los valores 1, 2, 3, 4, 5, luego aplicamos el operador takeWhile con una función predicate que evalúa si cada valor emitido es menor que 4. El operador takeWhile incluirá los valores 1, 2 y 3 pero detendrá la emisión de valores después de que se emita el valor 4 que no cumple la condición.

También es posible usar el argumento opcional inclusive para incluir o excluir el valor que no cumple la condición especificada. Por ejemplo:

import { of } from 'rxjs'
import { takeWhile } from 'rxjs/operators';

const source = of(1, 2, 3, 4, 5);

const example - source.pipe(
 takeWhile(x => x < 4, true)
);

example.subscribe(console.log) // salida: 1, 2, 3, 4

Donde en este caso el valor 4 a pesar de que no cumple la condición sera emitido por el por el Observable y detendrá la emisión de valores después de que se emita el valor 5 que no cumple la condición.

takeUntil

El operador takeUntil es un operador de finalización que emite valores de un Observable hasta que se emite un evento desde otro Observable.

La forma general del operador takeWhile es la siguiente:

takeUntil(notifier: Observable): Observable

El argumento notifier es un Observable que se utiliza para emitir un evento que indica que la emisión del Observable de origen debe finalizar. Cuando el notifier emite un valor o completa, el Observable de origin se completa y ya no se emiten mas valores.

Esta seria su grifa de canicas:

Aquí hay un ejemplo:

import { interval, timer } from 'rxjs';
import { takeUntil } from 'rxjs/operators';

const source = interval(1000);
const stopTimer = timer(5000);

const example = source.pipe(
 takeUntil(stopTimer)
);

example.subscribe(console.log) // salida: 0, 1, 2, 3, 4

En este ejemplo, creamos un Observable que emite valores cada segundo utilizando interval(1000), luego, creamos un Observable que completa después de 5 segundos utilizando timer(5000). Finalmente, aplicamos el operador takeUntil con el notifier stopTimer que completará la emisión del Observable de origin después de 5 segundos.

El resultado es que solo se emiten los primeros 5 valores del Observable de origen, ya que la emisión se detiene después de que el notifier stopTimer emite un valor y completa.

También podemos usar otros Observable como notifier para finalizar la emisión del Observable de origen, como un botón pulsado, una respuesta de una API, una conexión de red que se interrumpe, etc.

skip

El operador skip se utiliza para omitir los primeros elementos de un Observable y emitir los restantes.

La forma general del operador skip es la siguiente:

skip(count: number): Observable

El argumento count es un número entero que indica el número de elementos que se deben omitir antes de comenzar a emitir elementos.

Esta es la grafica de canicas para el operador skip:

Aqui un ejemplo:

import { of } from 'rxjs';
import { skip } from 'rxjs/operators';

const source = of(1, 2, 3, 4, 5);
const example = source.pipe(skip(3));

example.subscribe(console.log); // salida: 4, 5

En este ejemplo creamos un Observable que emite los valores 1, 2, 3, 4, 5 utilizando of(1, 2, 3, 4, 5) luego aplicamos el operador skip con un valor de 3, lo que significa que se omitirán los primeros 3 valores. La salida del Observable resultante es 4 y 5.

También podemos usar expresiones lógicas más complejas para determinar qué elementos se deben omitir. Por ejemplo, podríamos usar una expresión lambda que devuelve verdadero o falso en función de las propiedades de los elementos.

Es importante tener en cuenta que si el número de elementos a omitir es mayor o igual que el número total de elementos en el Observable, el Observable resultante sera vacío

distinct

El operador distinct se utiliza para emitir solo los valores únicos de un Observable omitiendo los valores que se han emitido previamente.

la forma general del operador distinct es la siguiente:

distinct(keySelector?: (value: T) => K, flushes?: Observable<any>): Observable<T>

El argumento opcional keySelector es una función que se utiliza para seleccionar una clave única para cada elemento. Si no se proporciona una función keySelector se utiliza el propio valor como clave.

El argumento opcional flushes es un Observable que se utiliza para limpiar la caché de valores previamente emitidos.

Tomemos este ejemplo:

import { of } from 'rxjs';
import { distinct } from 'rxjs/operators';

const source = of(1, 2, 3, 1, 2, 4, 5, 3);
const example = source.pipe(distinct());

example.subscribe(console.log); // salida: 1, 2, 3, 4, 5

En este ejemplo creamos un Observable que emite los valores 1, 2, 3, 1, 2, 4, 5, 3 utilizando of(1, 2, 3, 1, 2, 4, 5, 3) luego, aplicamos el operador distinct que omitirá los valores duplicados y emitirá solo los valores únicos. La salida del Observable resultante es 1, 2, 3, 4, 5.

También podemos usar la función keySelector para seleccionar una clave única basada en alguna propiedad o característica de los elementos. Por ejemplo, si tenemos un Observable que emite objetos de usuario con una propiedad id, podemos usar la función keySelector para emitir solo los objetos de usuario con id único:

import { of } from 'rxjs';
import { distinct } from 'rxjs/operators';


const users = [
 { id: 1, name: 'Alice },
 { id: 2, name: 'Bob },
 { id: 1, name: 'Charlie },
 { id: 3, name: 'David },
 { id: 2, name: 'Eve }
]
const source = of(users);
const example = source.pipe(distinct(user => user.id));

example.subscribe(console.log); // salida: { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }

En el ejemplo creamos un Observable que emite los objetos de usuario definidos en el array users. Luego, aplicamos el operador distinct con una función keySelector que selecciona la propiedad id de cada objeto de usuario como clave única. La salida del Observable resultante es solo los objetos de usuario con id único: { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }.

Es importante tener en cuenta que el operador distinct utiliza el cache interna para almacenar los valores emitidos previamente y determinar si un valor es único o no. Esto puede causar problemas de rendimiento si el Observable emite.
También es importante resaltar que el operador distinct utiliza el operador de equidad de triple igual === para comparar el valor emitido.

distinctUntilChanged

El operador distinctUntilChanged se utiliza para emitir solo los valores que no son iguales al valor anterior emitido por el Observable, es decir, si un valor se ha emitido previamente y es igual al valor actual, el valor actual se omite y no se emite.

La forma general del operador distinctUntilChanged es la siguiente:

distinctUntilChanged(compareFn?: (x: T, y: T) => boolean): MonoTypeOperatorFunction<T>

El argumento opcional compareFn es una función que se utiliza para comparar dos valores y determinar si son iguales o no. Si no se proporciona una función compareFn, se utiliza el operador === para comparar valores.

Por ejemplo:

import { of } from 'rxjs';
import { distinctUntilChanged } from 'rxjs/operators';

const source = of(1, 1, 2, 3, 3, 3, 4, 4, 5);
const example = source.pipe(distinctUntilChanged());

example.subscribe(console.log); // salida: 1, 2, 3, 4, 5

En este ejemplo creamos un Observable que emite los valores 1, 1, 2, 3, 3, 3, 4, 4, 5 utilizando al función of de rxjs, luego aplicamos el operador distinctUntilChanged que omitirá los valores duplicados y emitirá solos los valores que no son iguales al valor anterior emitido. La salida del Observable resultante es 1, 2, 3, 4, 5.

También podemos usar la función compareFn para personalizar la comparación de valores. Por ejemplo si tenemos un Observable que emite objetos de usuario con una propiedad name, podemos usar la función compareFn para omitir los objetos de usuario con el mismo nombre:

import { of } from 'rxjs';
import { distinctUntilChanged } from 'rxjs/operators';


const users = [
 { id: 1, name: 'Alice },
 { id: 2, name: 'Bob },
 { id: 1, name: 'Bob },
 { id: 3, name: 'David },
 { id: 2, name: 'David }
]

const source = of(...users);
const example = source.pipe(distinctUntilChanged((ant, act) => ant.name === act.name));

example.subscribe(console.log); // salida: { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }

En este ejemplo creamos un Observable que emite los objetos de usuario definidos en el array user, luego, aplicamos el operador distinctUntilChanged con una función compare que compara solo los nombres de usuario de dos objetos consecutivos. La salida del Observable resultante es solo los objetos de usuario cuyos nombres son diferentes a los del valor anterior: { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }

distinctUntilKeyChanged

El operador distinctUntilKeyChanged se utiliza para emitir solo los valores que son diferentes al valor anterior, basándose en una clave especifica de los objetos emitidos. Es similar al operador distinctUntilChanged, pero en lugar de comparar el valor completo emitido, solo compara el valor de una propiedad específica del objeto.

import { of } from 'rxjs';
import { distinctUntilKeyChanged } from 'rxjs/operators';


const users = [
 { id: 1, name: 'Alice },
 { id: 2, name: 'Bob },
 { id: 1, name: 'Bob },
 { id: 3, name: 'David },
 { id: 2, name: 'David }
]

const source = of(...users);
const example = source.pipe(distinctUntilKeyChanged('name');

example.subscribe(console.log); // salida: { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }

Como puedes ver, solo debemos especificar el key a comparar de los objetos emitido, en este caso el key es name y salida será { id: 1, name: 'Alice}, { id: 2, name 'Bob' }, { id: 3, name: 'David' }

Operadores básicos en RXJS

Alex Córdoba — Fri, 21 Apr 2023 22:15:57 +0000

Un operador es una función que se usa en un observable y controla y emite solo la información que nos interesa de la forma en que la necesitamos.

map

Nos permite transformar o extraer lo que emite el observable en algo diferente, manteniendo la estructura del flujo original. map es uno de los operadores más comunes y poderosos en RxJS, y se utiliza ampliamente para realizar transformaciones en los datos emitidos por un observable.

La sintaxis básica de map es la siguiente:



observable$.pipe(
  map(valor => nuevoValor)
)

Donde observable$ es el flujo de datos observable del cual se desean transformar los valores, y valor => nuevoValor es una función de transformación que toma cada valor emitido por el observable y devuelve un nuevo valor transformado.

Miremos su grafica de canicas:

ejemplo:
Transformación de valores: La función de transformación que se pasa como argumento a map es aplicada a cada valor emitido por el observable. Esta función toma el valor original y devuelve un nuevo valor transformado. Por ejemplo:



const numeros$ = of(1, 2, 3, 4, 5); // Observable que emite los números del 1 al 5

numeros$.pipe(
  map(numero => numero * 2) // Transforma cada número emitido por el observable multiplicándolo por 2
).subscribe(resultado => console.log(resultado));

El resultado de este código sería imprimir en la consola: 2, 4, 6, 8, 10, que son los valores originales multiplicados por 2.

filter

El operador filter es una función de filtrado que se utiliza para emitir solo aquellos elementos de un flujo de datos observable que cumplan con una condición especificada. En otras palabras, filter permite seleccionar elementos de un observable que satisfagan una condición dada y descartar aquellos que no la cumplan.

La sintaxis básica de filter es la siguiente:



observable$.pipe(
  filter(condicion)
)

Donde observable$ es el flujo de datos observable del cual se desean filtrar los elementos, y condicion es una función de predicado que especifica la condición que debe cumplir cada elemento emitido para ser seleccionado.
filter permite utilizar cualquier función de predicado que devuelva un valor booleano para evaluar la condición de filtrado. Esto proporciona una gran flexibilidad para especificar condiciones complejas basadas en cualquier propiedad o característica de los elementos emitidos por el observable.

Esta es su grafica de canicas:

veamos un ejemplo:



const personajes = [
    {
      tipo: 'heroe',
      nombre: 'Batman',
    },
    {
      tipo: 'heroe',
      nombre: 'Robin',
    },
    {
      tipo: 'villano',
      nombre: 'Joker',
    },
  ];

  from(personajes)
    .pipe(filter((personaje) => personaje.tipo === 'heroe'))
    .subscribe(console.log);

El resultado de este código sería imprimir en la consola {tipo: "heroe", nombre: "Batman"}, {tipo: "heroe", nombre: "Robin"}, que son los personajes que cumplen con la condición especificada en la función de predicado.

Una característica importante de filter es que los elementos que no cumplen con la condición especificada en la función de predicado no se emiten en el resultado del observable. Esto significa que solo los elementos que satisfacen la condición son emitidos, y los demás son ignorados y no se propagan en el flujo de datos.

tap

El operador tap es un operador de utilidad que permite realizar acciones secundarias o efectos secundarios en los elementos que fluyen a través de un flujo de datos observable, sin afectar la emisión o transformación de los elementos en sí. Es una herramienta poderosa para depurar, registrar o ejecutar lógica adicional en un flujo de datos observable sin modificar su comportamiento.

La sintaxis básica de tap es la siguiente:



observable$.pipe(
  tap(funcionEfecto)
)

Donde observable$ es el flujo de datos observable al cual se desea aplicar el efecto secundario, y funcionEfecto es una función que se ejecuta para cada elemento emitido por el observable, sin modificar el elemento en sí, y puede realizar cualquier lógica adicional deseada.

El operador tap ejecuta la función de efecto especificada para cada elemento emitido por el observable. La función de efecto puede ser una función con cualquier lógica adicional que desees realizar, como imprimir en la consola, registrar eventos, enviar datos a un servidor, etc. La función de efecto no modifica el elemento en sí, solo realiza acciones adicionales sobre él.

Aqui su grafica de canicas:



const numeros$ = of(1, 2, 3, 4, 5); // Observable que emite números

numeros$.pipe(
  tap(numero => console.log(`Número emitido: ${numero}`)) // Imprime en la consola cada número emitido
).subscribe();

El resultado de este código sería imprimir en la consola: Número emitido: 1, Número emitido: 2, Número emitido: 3, Número emitido: 4, Número emitido: 5, registrando cada número emitido por el observable.

Es importante tener en cuenta que tap no modifica los elementos emitidos por el observable. La función de efecto se ejecuta en paralelo con la emisión de los elementos, sin modificarlos. Si deseas modificar los elementos emitidos, deberás utilizar otros operadores de transformación de datos en combinación con tap.



const numeros$ = of(1, 2, 3, 4, 5); // Observable que emite números

numeros$.pipe(
  tap(x => console.log),
  map(val => val * 10)
).subscribe(val => console.log)

El resultado seria 10, 20, 30, 40, 50

reduce

El operador reduce es un operador de transformación que permite reducir una secuencia de valores en un solo valor, Este operador recibe una función de acumulación como argumento y aplica dicha función a los valores emitidos por la secuencia de entrada.

La función de acumulación toma dos argumentos: el acumulador y el valor actual emitido por la secuencia de entrada. El acumulador es el valor acumulado hasta el momento, mientras que el valor actual es el valor emitido por la secuencia en ese instante. La función de acumulación debe devolver un valor que se usará como el nuevo valor del acumulador.

La forma general del operador reduce en rxjs es la siguiente:



reduce(accumulator: function, seed?: any): Observable

El argumento accumulator es la función de acumulación que se aplicará a los valores emitidos por la secuencia. El argumento seed es un valor opcional que se utilizará como el valor inicial del acumulador. Si se proporciona seed, la función de acumulación se aplicará a seed y al primer valor emitido por la secuencia. Si no se proporciona seed la función de acumulación se aplicará al primer y segundo valor emitidos por la secuencia.
El operador reduce devuelve un Observable que emite un solo valor: el resultado final de la acumulación. Este valor se emite cuando la secuencia de entrada se completa.

Grafica de canicas:

Aquí hay un ejemplo:



import { of } from 'rxjs';
import { reduce } from 'rxjs/operators';

const source = of(1, 2, 3, 4, 5);

const example = source.pipe(
  reduce((acc, curr) => acc + curr)

example.subscribe(console.log) // salida: 15

En el ejemplo anterior, creamos un Observable que emite los valores 1, 2, 3, 4, 5. Luego, aplicamos el operador reduce con una función de acumulación que suma los valores. El resultado final de la acumulación es 15, que se emite cuando la secuencia de entrada se completa.

scan

El operador scan es un operador de transformación que es similar al operador reduce, pero en lugar de emitir un solo valor al final de la secuencia, emite un valor acumulado en cada paso de la secuencia.

La función de acumulación utilizada en scan es similar a la utilizada en reduce ya que toma dos argumentos: el acumulador y el valor actual emitido por la secuencia de entrada. La diferencia es que la función de acumulación devuelve el valor acumulado en lugar de devolver el valor que se usará como el nuevo valor de acumulador. En otras palabras scan emite el valor acumulado después de aplicar la función de acumulación a cada valor de la secuencia de entrada.

la forma general del operador scan es la siguiente:



scan(accumulator: function, seed?: any): Observable

El operador scan devuelve un Observable que emite el valor acumulado después de aplicar la función de acumulación a cada valor de la secuencia de entrada.

Esta es su grafica de canicas:

Por ejemplo:



import { of } from 'rxjs';
import { scan } from 'rxjs/operators';

const source = of(1, 2, 3, 4, 5);

const example = source.pipe(
  scan((acc, curr) => acc + curr)

example.subscribe(console.log) // salida: 1, 3, 6, 10, 15

En este ejemplo creamos un Observable que emite los valores 1, 2, 3, 4, 5 y luego aplicamos el operador scan con una función de acumulación que suma los valores. El valor acumulado después de aplicar la función de acumulación a cada valor de la secuencia de entrada se emite a cada paso de la secuencia. Es este caso, la salida es 1, 3, 6, 10, 15.

take

El operador take permite emitir los primero n valores emitidos por la secuencia de entrada. Una vez que se han emitido n valores, la secuencia se completa automáticamente y se detiene.

La sintaxis básica de take es la siguiente:



take(count: number): Oberservable

El argumento count especifica el número de valores que se deben emitir antes de completar la secuencia.

Esta es su grafica de canicas:

Aquí hay un ejemplo de cómo usar el operador take en Rxjs



import { interval } from 'rxjs'
import { take } from 'rxjs/operators';

const source = interval(1000);

const example = source.pipe(
  take(5)
);

example.subscribe(console.log) // salida: 0, 1, 2, 3, 4

En este ejemplo, creamos un Observable que emite un valor cada segundo utilizando el operador interval. Luego, aplicamos el operador take con un argumento de 5, lo que significa que solo se emitirán los primeros 5 valores emitidos por la secuencia. La salida del subscribe es 0, 1, 2, 3, 4.

EL operador take también se puede combinar con otros operadores de rxjs, como filter, map, mergeMap, etc. para manipular y limitar los valores emitidos por la secuencia de entrada.

Metodos para Arrays en Javascript

Alex Córdoba — Fri, 31 Mar 2023 16:04:12 +0000

Hola devs... en este compacto pero util post encontraras los métodos mas comunes que puedes usar con Arrays en javascript. Los métodos que veremos serán pop, push, unshift, splice, slice, reduce, sort, concat, flat, filter, join, map, find, filter includes, indexOf, some y forEach así que ponte cómodo y empecemos.

Metodos

Antes de entrar en materia es importarte saber que algunos de estos métodos mutan directamente el array original haciendo que sus valores o propiedades cambien. Por otra parte tenemos los métodos que no mutan o cambian el array original si no que crean un nuevo array a partir del original.
Así que cuando estes viendo un método que tenga la palabra muta o no muta entre paréntesis ya sabes que significa.

`pop (muta)`

El método pop elimina el último elemento de un array y retorna el elemento eliminado. El método pop() muta el array original, es decir, modifica el array al que se aplica. El método pop() no toma ningún argumento si el array está vacío, pop() devuelve undefined, por ejemplo:

const miArray = [1, 2, 3, 4, 5];
const elementoEliminado = miArray.pop();
console.log(miArray); // [1, 2, 3, 4]
console.log(elementoEliminado); // 5

En el ejemplo anterior, pop() elimina el último elemento del array miArray (que es el valor 5) y devuelve ese valor como resultado. El array original fue modificado y ahora su longitud es de 4.

`push (muta)`

El método push() permite agregar uno o más elementos al final de un array. Este método muta el array original, es decir, modifica el array al que se aplica. El método push() toma uno o más argumentos y retorna la longitud actualizada del array.

const miArray = [1, 2, 3];
const nuevaLongitud = miArray.push(4, 5);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5

En el ejemplo anterior, push() agrega los valores 4 y 5 al final del array miArray y retorna la nueva longitud del array como resultado.

`unshift (muta)`

El método unshift() permite agregar uno o más elementos al inicio de un array. El método unshift() muta el array original, es decir, modifica el array al que se aplica. Al igual que el método push el método unshift toma uno o más argumentos y devuelve la nueva longitud del array.

const miArray = [3, 4, 5];
const nuevaLongitud = miArray.unshift(1, 2);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5

unshift agrega los valores 1 y 2 al inicio del array miArray y devuelve la nueva longitud (5) del array como resultado.

`splice (muta)`

El método splice() permite agregar, eliminar o reemplazar elementos en un array. El método splice muta el array original, es decir, modifica el array al que se aplica.
El método splice() toma tres o más argumentos:

El primer argumento especifica la posición del índice en el array desde el cual se va a iniciar la operación.
El segundo argumento (opcional) especifica la cantidad de elementos que se eliminarán a partir de la posición del índice.
Los argumentos adicionales (opcional) especifican los elementos que se agregarán a partir de la posición del índice.

const miArray = [1, 2, 3, 4, 5];
const elementosEliminados = miArray.splice(2, 2);
console.log(miArray); // [1, 2, 5]
console.log(elementosEliminados); // [3, 4]

En este ejemplo, splice se utiliza para eliminar dos elementos a partir de la posición del índice 2. Como resultado, se eliminan los elementos 3 y 4 del array miArray y se devuelve un array que contiene los elementos eliminados. Nota que el array original ahora tiene 3 elementos lo que indica que fue modificado por el método splice.

const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 0, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 3, 4, 5]

En este ejemplo splice se utiliza para agregar los elementos 6 y 7 a partir de la posición del índice 2. Como resultado, los elementos 6 y 7 se agregan al array miArray y desplazan los elementos siguientes hacia la derecha.

const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 2, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 5]

En el ejemplo anterior, splice se utiliza para reemplazar los elementos 3 y 4 a partir de la posición del índice 2 con los elementos 6 y 7. Como resultado, los elementos 3 y 4 se eliminan del array miArray y se agregan los elementos 6 y 7 en su lugar.

`slice (no muta)`

El método slice() permite crear una copia de una porción de un array, sin modificar el array original. El método slice devuelve una nueva matriz que incluye los elementos seleccionados del array original.

Este método toma dos argumentos opcionales:

El primer argumento especifica la posición del índice donde comenzar a copiar elementos. Si este argumento es omitido, slice() copiará desde el inicio del array (índice 0).
El segundo argumento especifica la posición del índice donde finalizar la copia de elementos. Si este argumento es omitido, slice() copiará hasta el final del array.

veamos unos cuantos ejemplos

const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice();
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [1, 2, 3, 4, 5]

En el ejemplo anterior, slice se utiliza para crear una copia completa del array miArray. Como resultado, se crea una nueva matriz que contiene los mismos elementos que el array original.

const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(1, 4);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [2, 3, 4]

En este ejemplo, slice se utiliza para crear una copia de los elementos entre los índices 1 y 4 del array miArray. Como resultado, se crea una nueva matriz que contiene los elementos 2, 3 y 4.

const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(-3);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [3, 4, 5]

En el ejemplo anterior, slice() se utiliza para crear una copia de los últimos tres elementos del array miArray. Como resultado, se crea una nueva matriz que contiene los elementos 3, 4 y 5.

`reduce (no muta)`

El método reduce se utiliza para iterar sobre los elementos de un arreglo y acumular un valor final a través de una función reductora. La función reductora toma dos argumentos: el acumulador y el valor actual del arreglo.

La sintaxis básica de la función reduce es la siguiente:

array.reduce(function(acumulador, valorActual, index, arreglo) {
  // código de la función reductora
}, valorInicial);

Los parámetros de la función reductora son los siguientes:

acumulador: el valor acumulado de la iteración anterior, o el valor inicial proporcionado en el segundo argumento de la función reduce.
valorActual: el valor actual del arreglo en la iteración actual.
index (opcional): el índice del elemento actual en el arreglo.
arreglo (opcional): el arreglo original que se está reduciendo.

El segundo argumento de la función reduce es el valor inicial del acumulador. Si este argumento no se proporciona, el valor inicial será el primer elemento del arreglo y la iteración comenzará desde el segundo elemento.
La función reductora debe devolver el valor actualizado del acumulador en cada iteración. El valor actualizado del acumulador se utilizará como el acumulador en la siguiente iteración. Cuando se completa la iteración, el valor final del acumulador se devuelve como resultado de la función reduce.
Por ejemplo, podemos utilizar la función reduce para sumar los elementos de un arreglo de números de la siguiente manera:

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

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

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

En este ejemplo, el valor inicial del acumulador es 0 y la función reductora suma el valor actual del arreglo al acumulador en cada iteración. Al final de la iteración, el valor final del acumulador es 15, que se devuelve como resultado de la función reduce.

La función reduce es muy versátil y se puede utilizar para realizar muchas otras operaciones en los arreglos, como encontrar el valor máximo o mínimo, concatenar elementos de una cadena, crear un objeto a partir de un arreglo, entre otros.

`sort (muta)`

El método sort() se utiliza para ordenar los elementos de un arreglo en su lugar, es decir, modifica el arreglo original.
Algo importante a tener en cuenta, todos los elementos indefinidos se ordenan al final de la matriz.

La sintaxis básica de la función sort() es la siguiente:

array.sort([comparador])

El parámetro opcional comparador es una función callback que se utiliza para especificar el criterio de ordenación. Si no se proporciona ningún argumento, los elementos del arreglo se ordenarán como cadenas de caracteres. Si se proporciona un comparador, se utilizará para comparar los elementos del arreglo y determinar su orden.

La función comparadora toma dos argumentos, que representan dos elementos del arreglo que se están comparando. La función debe devolver un número negativo si el primer elemento es menor que el segundo, un número positivo si el primer elemento es mayor que el segundo, o cero si ambos elementos son iguales.

Por ejemplo, podemos utilizar la función sort() para ordenar un arreglo de números de la siguiente manera:

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

numeros.sort(function(a, b) {
  return a - b;
});

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

En este ejemplo, la función comparadora resta el segundo elemento del primero y devuelve el resultado. Esto ordena los elementos del arreglo en orden ascendente.

También podemos utilizar la función sort() para ordenar un arreglo de objetos según una propiedad específica. Por ejemplo:

const personas = [  { nombre: 'Ana', edad: 24 },  { nombre: 'Pedro', edad: 31 },  { nombre: 'Juan', edad: 18 },  { nombre: 'María', edad: 27 },  { nombre: 'Luis', edad: 22 },];

personas.sort(function(a, b) {
  if (a.edad < b.edad) {
    return -1;
  }
  if (a.edad > b.edad) {
    return 1;
  }
  return 0;
});

console.log(personas); // salida: [
                        //   { nombre: 'Juan', edad: 18 },
                        //   { nombre: 'Luis', edad: 22 },
                        //   { nombre: 'Ana', edad: 24 },
                        //   { nombre: 'María', edad: 27 },
                        //   { nombre: 'Pedro', edad: 31 }
                        // ]

En este ejemplo, la función comparadora compara los objetos según su propiedad edad y devuelve un número negativo, positivo o cero según el orden correspondiente.

En resumen, el método sort() en JavaScript se utiliza para ordenar los elementos de un arreglo en su lugar. La función comparadora especifica el criterio de ordenación y toma dos elementos como argumentos, y devuelve un número negativo, positivo o cero según el orden correspondiente. Es importante destacar que sort() modifica el arreglo original.

`concat (no muta)`

El método concat() se utiliza para concatenar uno o más arreglos con el arreglo actual y crear un nuevo arreglo sin modificar los arreglos originales.

La sintaxis básica de la función concat() es la siguiente:

array.concat(valor1, valor2, ..., valorN)

Donde valor1, valor2, ..., valorN son uno o más valores o arreglos que se desean concatenar con el arreglo actual.

La función concat() devuelve un nuevo arreglo que contiene los elementos del arreglo actual y los elementos de los arreglos pasados como argumentos en el orden en que se proporcionan. Si uno de los argumentos de concat() es un arreglo, los elementos de ese arreglo se agregan individualmente al nuevo arreglo.

Por ejemplo, podemos utilizar la función concat() para concatenar dos arreglos de la siguiente manera:

const numeros1 = [1, 2, 3];
const numeros2 = [4, 5, 6];
const numerosConcatenados = numeros1.concat(numeros2);

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

En este ejemplo, la función concat() se utiliza para concatenar los arreglos numeros1 y numeros2 en un nuevo arreglo llamado numerosConcatenados.

También podemos utilizar la función concat() para concatenar un valor o varios valores al arreglo actual. Por ejemplo:

const nombres = ['Ana', 'Pedro', 'Juan'];
const nombresConcatenados = nombres.concat('María', 'Luis');

console.log(nombresConcatenados); // salida: ['Ana', 'Pedro', 'Juan', 'María', 'Luis']

En este ejemplo, la función concat() se utiliza para concatenar los valores 'María' y 'Luis' al arreglo nombres en un nuevo arreglo llamado nombresConcatenados.

Es importante destacar que la función concat() no modifica los arreglos originales, sino que devuelve un nuevo arreglo que contiene los elementos de los arreglos concatenados.

a tener en cuenta: concat copia las referencias de objeto del original en la nueva matriz para que tanto la matriz original como la nueva se refieran al mismo objeto.
Por lo tanto, si se modifica un objeto al que se hace referencia, los cambios son visibles tanto para las matrices nuevas como para las originales.

`flat (no muta)`

El método flat() se utiliza para "aplanar" un arreglo multidimensional en un arreglo unidimensional.

La sintaxis básica de la función flat() es la siguiente:

array.flat(depth)

Donde depth es un número que indica la profundidad máxima a la que se deben aplanar los subarreglos. Si se omite el argumento depth, se asume un valor de 1, lo que significa que se aplanará un solo nivel de subarreglos.

La función flat() devuelve un nuevo arreglo que contiene todos los elementos del arreglo original, pero aplanados en un solo nivel.

Por ejemplo, podemos utilizar la función flat() para aplanar un arreglo multidimensional de la siguiente manera:

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

const numerosAplanados = numeros.flat();

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

En este ejemplo, la función flat() se utiliza para aplanar el arreglo numeros, que contiene tres niveles de subarreglos. El resultado es un nuevo arreglo llamado numerosAplanados que contiene todos los elementos del arreglo original aplanados en un solo nivel.

También podemos utilizar la función flat() con un argumento depth para aplanar subarreglos en diferentes niveles de profundidad. Por ejemplo:

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

const numerosAplanados = numeros.flat(2);

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

En este ejemplo, la función flat() se utiliza con un argumento depth de 2 para aplanar el arreglo numeros hasta un máximo de dos niveles de profundidad. El resultado es un nuevo arreglo llamado numerosAplanados que contiene todos los elementos del arreglo original aplanados en un solo nivel.

Es importante destacar que la función flat() no modifica el arreglo original, sino que devuelve un nuevo arreglo que contiene los elementos aplanados. Si uno de los elementos del arreglo original es un objeto, la función flat() no lo modificará, simplemente lo incluirá en el nuevo arreglo aplanado.

`filter (no muta)`

El método filter() se utiliza para filtrar los elementos de un arreglo según una condición especificada en una función de callback. La función de callback debe devolver un valor booleano que indica si el elemento debe ser incluido en el nuevo arreglo resultante o no.

La sintaxis básica de la función filter() es la siguiente:

array.filter(callback(element[, index[, array]])[, thisArg])

Donde callback es la función que se utilizará para filtrar los elementos del arreglo, element es el elemento actual que se está evaluando, index es el índice del elemento actual y array es el arreglo original. El argumento thisArg es opcional y se refiere al valor de this que se utilizará dentro de la función de callback.

La función filter() devuelve un nuevo arreglo que contiene solo los elementos del arreglo original que pasaron la prueba de la función de callback. Es decir, si la función de callback devuelve true, el elemento se incluirá en el nuevo arreglo, y si devuelve false, el elemento se omitirá.

Por ejemplo, podemos utilizar la función filter() para filtrar solo los números pares de un arreglo de la siguiente manera:

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

const numerosPares = numeros.filter(function(num) {
  return num % 2 === 0;
});

console.log(numerosPares); // salida: [2, 4, 6]

En este ejemplo, la función filter() se utiliza para crear un nuevo arreglo llamado numerosPares que contiene solo los números pares del arreglo original numeros. La función de callback utiliza el operador % para comprobar si el número actual es divisible por 2 y, si es así, devuelve true, lo que significa que el número debe ser incluido en el nuevo arreglo.

También podemos utilizar la función filter() con funciones de callback más complejas para filtrar elementos de un arreglo según múltiples criterios. Por ejemplo:

const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const personasMayores = personas.filter(function(persona) {
  return persona.edad > 25 && persona.nombre.startsWith('M');
});

console.log(personasMayores); // salida: [{ nombre: 'María', edad: 30 }]

En este ejemplo, la función filter() se utiliza para crear un nuevo arreglo llamado personasMayores que contiene solo las personas mayores de 25 años cuyo nombre comienza con la letra "M". La función de callback utiliza las propiedades edad y nombre de cada objeto para comprobar si cumple con los criterios especificados.

Es importante destacar que la función filter() no modifica el arreglo original, sino que devuelve un nuevo arreglo que contiene solo los elementos que cumplieron con la condición de la función de callback.

`join (no muta)`

El método join() se utiliza para concatenar todos los elementos de un arreglo en una sola cadena de texto. El método join() recibe un argumento opcional que especifica el separador que se utilizará para separar cada elemento en la cadena resultante.

La sintaxis básica de la función join() es la siguiente:

array.join([separator])

Donde separator es el separador que se utilizará para separar cada elemento en la cadena resultante. Si este argumento no se proporciona, se utilizará una coma (",") como separador por defecto.

El método join() devuelve una cadena que contiene todos los elementos del arreglo separados por el separador especificado.

Por ejemplo, podemos utilizar la función join() para concatenar los elementos de un arreglo en una sola cadena separada por guiones:

const palabras = ['hola', 'mundo', 'feliz', 'día'];
const frase = palabras.join('-');

console.log(frase); // salida: "hola-mundo-feliz-día"

En este ejemplo, la función join() se utiliza para concatenar los elementos del arreglo palabras en una sola cadena separada por guiones. El resultado se asigna a la variable frase.

También podemos utilizar la función join() para crear una cadena a partir de un arreglo de objetos. En este caso, debemos proporcionar una función de callback para convertir cada objeto en una cadena antes de concatenarlo con los demás elementos. Por ejemplo:

const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const lista = personas.map(function(persona) {
  return persona.nombre + ' (' + persona.edad + ' años)';
}).join(', ');

console.log(lista); // salida: "Juan (25 años), María (30 años), Pedro (20 años)"

En este ejemplo, la función map() se utiliza para crear un nuevo arreglo que contiene una cadena para cada objeto en el arreglo personas. La función de callback utiliza las propiedades nombre y edad de cada objeto para construir la cadena. Luego, la función join() se utiliza para concatenar todas las cadenas en una sola lista separada por comas.

El método join() no modifica el arreglo original, sino que devuelve una nueva cadena que contiene todos los elementos del arreglo concatenados.

`map (no muta)`

El método map() se utiliza en los objetos de tipo Array para crear un nuevo arreglo a partir de un arreglo existente. El nuevo arreglo resultante se crea aplicando una función de transformación a cada elemento del arreglo original. En otras palabras, el método map() itera sobre los elementos de un arreglo y devuelve un nuevo arreglo con los resultados de aplicar una función a cada elemento.

La sintaxis básica del método map() es la siguiente:

array.map(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return newValue;
});

Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de transformación que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve el resultado de la transformación.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos crear un nuevo arreglo donde cada número se multiplica por dos. Podemos utilizar el método map() para lograr esto de la siguiente manera:

const numeros = [1, 2, 3, 4, 5];
const numerosDobles = numeros.map(function(numero) {
  return numero * 2;
});

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

En este ejemplo, la función de transformación toma cada número del arreglo original y lo multiplica por dos. El resultado se almacena en un nuevo arreglo llamado numerosDobles.

El método map() también se puede utilizar para transformar un arreglo de objetos. En este caso, la función de transformación debe devolver un objeto con las propiedades transformadas que deseamos incluir en el nuevo arreglo. Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos crear un nuevo arreglo que contenga solo los nombres de estas personas:

const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const nombres = personas.map(function(persona) {
  return persona.nombre;
});

console.log(nombres); // salida: ['Juan', 'María', 'Pedro']

En este ejemplo, la función de transformación devuelve la propiedad nombre de cada objeto en el arreglo original. El resultado se almacena en un nuevo arreglo llamado nombres.

Es importante destacar que el método map() no modifica el arreglo original, sino que devuelve un nuevo arreglo con los resultados de la transformación. El nuevo arreglo tendrá la misma longitud que el arreglo original.

`find (no muta)`

El método find() en JavaScript es una función que se utiliza en los objetos de tipo Array para buscar un elemento específico dentro del arreglo. El método devuelve el primer elemento que cumple con la condición especificada en una función de prueba. Si no se encuentra ningún elemento que cumpla con la condición, el método devuelve undefined.

La sintaxis básica del método find() es la siguiente:

array.find(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return condition;
});

Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de prueba que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve un valor booleano que indica si el elemento cumple con la condición de búsqueda.

Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos buscar la primera persona que tenga una edad mayor a 25 años. Podemos utilizar el método find() para lograr esto de la siguiente manera:

const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const personaMayor25 = personas.find(function(persona) {
  return persona.edad > 25;
});

console.log(personaMayor25); // salida: { nombre: 'María', edad: 30 }

En este ejemplo, la función de prueba evalúa si la edad de la persona actual es mayor a 25 años. El método find() devuelve el primer elemento del arreglo que cumple con esta condición, que en este caso es el objeto que representa a María.

El método find() también se puede utilizar para buscar un elemento en un arreglo de valores simples. En este caso, la función de prueba debe evaluar si el valor actual es igual al valor que estamos buscando. Por ejemplo, supongamos que tenemos un arreglo de números y queremos buscar el primer número que sea divisible por 3:

const numeros = [1, 4, 7, 9, 12, 15];

const numeroDivisible3 = numeros.find(function(numero) {
  return numero % 3 === 0;
});

console.log(numeroDivisible3); // salida: 9

En este ejemplo, la función de prueba evalúa si el número actual es divisible por 3 utilizando el operador %. El método find() devuelve el primer elemento del arreglo que cumple con esta condición, que en este caso es el número 9.

Es importante destacar que el método find() devuelve solo el primer elemento que cumple con la condición de búsqueda. Si hay varios elementos que cumplen con la condición, solo se devuelve el primero que se encuentre. Si se requiere encontrar todos los elementos que cumplan con la condición, se debe utilizar el método filter().

`filter (no muta)`

El método filter() se utiliza en los objetos de tipo Array para filtrar elementos que cumplen con una condición especificada y devuelve un nuevo arreglo con los elementos que cumplen con dicha condición. La sintaxis básica del método filter() es la siguiente:

array.filter(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return condition;
});

Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de prueba que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve un valor booleano que indica si el elemento cumple con la condición de búsqueda.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos filtrar solo los números que son pares. Podemos utilizar el método filter() para lograr esto de la siguiente manera:

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

const numerosPares = numeros.filter(function(numero) {
  return numero % 2 === 0;
});

console.log(numerosPares); // salida: [2, 4, 6]

En este ejemplo, la función de prueba evalúa si el número actual es par utilizando el operador %. El método filter() devuelve un nuevo arreglo con los elementos del arreglo original que cumplen con esta condición, que en este caso son los números pares.

El método filter() también se puede utilizar para filtrar elementos de un arreglo de objetos. En este caso, la función de prueba debe evaluar si alguna propiedad del objeto cumple con la condición de búsqueda. Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos filtrar solo las personas que son mayores de edad:

const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 17 }
];

const personasMayoresEdad = personas.filter(function(persona) {
  return persona.edad >= 18;
});

console.log(personasMayoresEdad); // salida: [{ nombre: 'Juan', edad: 25 }, { nombre: 'María', edad: 30 }]

En este ejemplo, la función de prueba evalúa si la edad de la persona actual es mayor o igual a 18 años. El método filter() devuelve un nuevo arreglo con los objetos del arreglo original que cumplen con esta condición, que en este caso son las personas mayores de edad.

Es importante destacar que el método filter() devuelve un nuevo arreglo con los elementos que cumplen con la condición de búsqueda. El arreglo original no se modifica. Si se requiere modificar el arreglo original, se debe utilizar el método map().

`includes (no muta)`

El método includes() en JavaScript es una función que se utiliza en los objetos de tipo Array para determinar si un valor específico se encuentra en el arreglo. La sintaxis básica del método includes() es la siguiente:

array.includes(valueToFind[, fromIndex])

Donde array es el arreglo en el que se realizará la búsqueda, valueToFind es el valor que se busca en el arreglo y fromIndex es un índice opcional que indica el índice desde el cual comenzar la búsqueda.

El método includes() devuelve un valor booleano que indica si el valor especificado se encuentra en el arreglo o no. Si el valor se encuentra en el arreglo, se devuelve true; de lo contrario, se devuelve false.

Por ejemplo, supongamos que tenemos un arreglo de nombres y queremos determinar si un nombre específico se encuentra en el arreglo. Podemos utilizar el método includes() para lograr esto de la siguiente manera:

const nombres = ['Juan', 'María', 'Pedro'];

const estaJuan = nombres.includes('Juan');
const estaLuis = nombres.includes('Luis');

console.log(estaJuan); // salida: true
console.log(estaLuis); // salida: false

En este ejemplo, el método includes() se utiliza para determinar si el nombre "Juan" se encuentra en el arreglo. El método devuelve true, lo que indica que el nombre se encuentra en el arreglo. Luego, el método se utiliza para determinar si el nombre "Luis" se encuentra en el arreglo. El método devuelve false, lo que indica que el nombre no se encuentra en el arreglo.

También podemos utilizar el segundo argumento opcional fromIndex para indicar el índice desde el cual comenzar la búsqueda. Por ejemplo:

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

const estaCinco = numeros.includes(5, 3);

console.log(estaCinco); // salida: true

En este ejemplo, el método includes() se utiliza para determinar si el valor 5 se encuentra en el arreglo numeros comenzando desde el índice 3. El método devuelve true, lo que indica que el valor se encuentra en el arreglo.

Es importante destacar que el método includes() realiza una búsqueda estricta, es decir, compara los valores utilizando el operador de igualdad estricta (===). Esto significa que los valores deben ser del mismo tipo y tener el mismo valor para que el método devuelva true. Por ejemplo, si buscamos el número 2 en el arreglo ['2'], el método includes() devolverá false, ya que los valores no son del mismo tipo.

`indexof (no muta)`

El método indexOf() en JavaScript se utiliza para buscar la posición de un elemento especificado dentro de un arreglo. La sintaxis básica del método indexOf() es la siguiente:

array.indexOf(searchElement[, fromIndex])

Donde array es el arreglo en el que se realizará la búsqueda, searchElement es el elemento que se busca en el arreglo y fromIndex es un índice opcional que indica el índice desde el cual comenzar la búsqueda.

El método indexOf() devuelve el índice del primer elemento que coincida con el valor especificado o -1 si el valor no se encuentra en el arreglo.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos determinar la posición del número 3 dentro del arreglo. Podemos utilizar el método indexOf() para lograr esto de la siguiente manera:

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

const posicionTres = numeros.indexOf(3);

console.log(posicionTres); // salida: 2

En este ejemplo, el método indexOf() se utiliza para determinar la posición del número 3 dentro del arreglo numeros. El método devuelve 2, que es el índice del primer elemento que coincide con el valor especificado.

También podemos utilizar el segundo argumento opcional fromIndex para indicar el índice desde el cual comenzar la búsqueda. Por ejemplo:

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

const posicionCuatro = numeros.indexOf(4, 2);

console.log(posicionCuatro); // salida: 3

En este ejemplo, el método indexOf() se utiliza para determinar la posición del número 4 dentro del arreglo numeros comenzando desde el índice 2. El método devuelve 3, que es el índice del primer elemento que coincide con el valor especificado a partir del índice 2.

Es importante destacar que el método indexOf() devuelve el índice del primer elemento que coincida con el valor especificado. Si hay varios elementos que coinciden con el valor especificado, el método solo devuelve el índice del primer elemento. Si queremos buscar la posición de todos los elementos que coincidan con el valor especificado, podemos utilizar el método filter() en combinación con el método indexOf().

`some`

El método some() en JavaScript se utiliza para comprobar si al menos un elemento de un arreglo cumple con una condición determinada. La sintaxis básica del método some() es la siguiente:

array.some(callback[, thisArg])

Donde array es el arreglo en el que se realiza la comprobación, callback es una función que se ejecuta en cada elemento del arreglo y thisArg es un valor opcional que se utiliza como this dentro de la función de devolución de llamada.

La función de devolución de llamada (callback) que se pasa como argumento al método some() debe devolver un valor booleano (true o false). La función se ejecuta una vez por cada elemento en el arreglo hasta que un elemento devuelva true. Si la función devuelve true para al menos un elemento del arreglo, el método some() devuelve true, de lo contrario devuelve false.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos comprobar si al menos uno de los elementos es mayor que 10. Podemos utilizar el método some() para lograr esto de la siguiente manera:

const numeros = [1, 2, 15, 4, 5];

const alMenosUnoMayorQueDiez = numeros.some((numero) => {
  return numero > 10;
});

console.log(alMenosUnoMayorQueDiez); // salida: true

En este ejemplo, el método some() se utiliza para comprobar si al menos uno de los elementos del arreglo numeros es mayor que 10. La función de devolución de llamada devuelve true para el elemento 15, por lo que el método some() devuelve true.

`forEach`

El método forEach() en JavaScript se utiliza para iterar sobre los elementos de un arreglo y ejecutar una función para cada elemento. La sintaxis básica del método forEach() es la siguiente:

array.forEach(callback[, thisArg])

Donde array es el arreglo sobre el que se itera, callback es la función que se ejecuta para cada elemento y thisArg es un valor opcional que se utiliza como this dentro de la función de devolución de llamada.

La función de devolución de llamada (callback) que se pasa como argumento al método forEach() se ejecuta una vez para cada elemento del arreglo, en orden. La función puede tener hasta tres argumentos: el valor del elemento actual, el índice del elemento actual y el arreglo sobre el que se está iterando.

La función de devolución de llamada puede realizar cualquier tarea necesaria para cada elemento del arreglo, como actualizar el valor de cada elemento o realizar un cálculo basado en los valores de los elementos. Es importante tener en cuenta que el método forEach() no devuelve ningún valor, simplemente ejecuta la función de devolución de llamada para cada elemento del arreglo.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos imprimir cada número en la consola. Podemos utilizar el método forEach() para lograr esto de la siguiente manera:

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

numeros.forEach((numero) => {
  console.log(numero);
});

En este ejemplo, el método forEach() se utiliza para iterar sobre el arreglo numeros y ejecutar la función de devolución de llamada para cada elemento del arreglo. La función de devolución de llamada simplemente imprime cada número en la consola.