FUNCIÓN RECURSIVA:

Una función recursiva en JavaScript es una función que se llama a sí misma de manera repetida hasta que se alcanza
una condición de salida o límite. Es decir, la función se llama a sí misma para resolver un problema de forma iterativa.

La recursividad es un concepto importante en la programación y se utiliza en muchos algoritmos y estructuras de

datos. En JavaScript, una función recursiva generalmente tiene dos partes: la primera parte es la condición de salida
que indica cuándo se debe detener la recursión, y la segunda parte es la llamada recursiva que se realiza para seguir
resolviendo el problema.

Aquí hay un ejemplo de una función recursiva en JavaScript que calcula el factorial de un número:
function factorial(n) {
if (n <= 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}

En JavaScript, una clausura o closure se produce cuando una función interna tiene acceso a variables de su función
externa, incluso después de que la función externa haya finalizado su ejecución. Esto significa que la función interna
puede seguir accediendo y manipulando esas variables externas, incluso si la función externa ya no está en la pila de
llamadas. Las clausuras son una característica poderosa de JavaScript que permite crear funciones más flexibles y
reutilizables.

Aquí hay un ejemplo de una clausura en JavaScript:

function saludar(nombre) {
var mensaje = 'Hola ' + nombre + '!';
function mostrarMensaje() {
console.log(mensaje);
}
return mostrarMensaje;
}

var saludarJuan = saludar('Juan');

saludarJuan(); // "Hola Juan!"

En este ejemplo, la función saludar() retorna otra función llamada mostrarMensaje(), que tiene acceso a la variable
mensaje de la función saludar(). Cuando se llama a saludar(), se crea una clausura que permite que la función
interna mostrarMensaje() tenga acceso a la variable mensaje incluso después de que la función saludar() haya
finalizado su ejecución. En este caso, la función saludar() retorna la función mostrarMensaje(), que luego se asigna a
la variable saludarJuan. Luego, cuando se llama a saludarJuan(), se ejecuta la función interna mostrarMensaje(), que
tiene acceso a la variable mensaje y muestra el mensaje "Hola Juan!" en la consola.

CLAUSURAS EN JAVASCRIPT

En JavaScript, una clausura o closure se produce cuando una función interna tiene acceso a variables de su función
externa, incluso después de que la función externa haya finalizado su ejecución. Esto significa que la función interna
puede seguir accediendo y manipulando esas variables externas, incluso si la función externa ya no está en la pila de
llamadas. Las clausuras son una característica poderosa de JavaScript que permite crear funciones más flexibles y
reutilizables.

Aquí hay un ejemplo de una clausura en JavaScript:

function saludar(nombre) {
var mensaje = 'Hola ' + nombre + '!';
function mostrarMensaje() {
console.log(mensaje);
}
return mostrarMensaje;
}
var saludarJuan = saludar('Juan');
saludarJuan(); // "Hola Juan!"

En este ejemplo, la función saludar() retorna otra función llamada mostrarMensaje(), que tiene acceso a la variable
mensaje de la función saludar(). Cuando se llama a saludar(), se crea una clausura que permite que la función
interna mostrarMensaje() tenga acceso a la variable mensaje incluso después de que la función saludar() haya
finalizado su ejecución. En este caso, la función saludar() retorna la función mostrarMensaje(), que luego se asigna a
la variable saludarJuan. Luego, cuando se llama a saludarJuan(), se ejecuta la función interna mostrarMensaje(), que
tiene acceso a la variable mensaje y muestra el mensaje "Hola Juan!" en la consola.

PARÁMETRO REST COMO ARGUMENTO

En JavaScript, el parámetro rest permite a una función aceptar un número variable de argumentos como un array.

Para utilizar el parámetro rest, se utiliza el operador de propagación ... antes del nombre del parámetro. De esta
manera, cualquier número de argumentos que se le pasen a la función se agruparán en un array.

Aquí hay un ejemplo:

function sumar(...numeros) {
let total = 0;
for (let numero of numeros) {
total += numero;
}
return total;
}
console.log(sumar(1, 2, 3, 4, 5)); // output: 15
console.log(sumar(10, 20)); // output: 30
console.log(sumar(2, 4, 6, 8)); // output: 20

En el ejemplo anterior, la función sumar utiliza el parámetro rest ...numeros para aceptar cualquier número de
argumentos. Los argumentos se agrupan en un array, que se recorre con un bucle for y se suma cada elemento. REST
DEBE SER EL ULTIMO PARAMETRO

DESCTRUCTURACION EN JAVASCRIPT

La destructuración es una forma de extraer valores de un objeto o de un array y asignarlos a variables en una sola
línea de código. Es una forma conveniente y legible de trabajar con objetos y arrays en JavaScript.

Aquí tienes un ejemplo de destructuración de un objeto:

const objeto = { nombre: 'Juan', apellido: 'Pérez', edad: 30 };

const { nombre, apellido, edad } = objeto;

console.log(nombre); // 'Juan'
console.log(apellido); // 'Pérez'
console.log(edad); // 30

En este ejemplo, la sintaxis { nombre, apellido, edad } = objeto extrae los valores correspondientes del objeto objeto
y los asigna a las variables nombre, apellido y edad respectivamente.

Aquí tienes otro ejemplo de destructuración de un array:

const array = ['manzana', 'banana', 'naranja'];

const [primera, segunda, tercera] = array;

console.log(primera); // 'manzana'
console.log(segunda); // 'banana'
console.log(tercera); // 'naranja'

en este ejemplo, la sintaxis [primera, segunda, tercera] = array extrae los valores correspondientes del array array y
los asigna a las variables primera, segunda y tercera respectivamente.

OPERADORES TERNARIOS

El operador ternario en JavaScript es una forma abreviada de una estructura de control if/else. Su sintaxis es
la siguiente:

condicion ? valorSiVerdadero : valorSiFalso

La condicion se evalúa primero. Si es verdadera, entonces se devuelve el valorSiVerdadero , de lo

contrario se devuelve el valorSiFalso .

Aquí te muestro un ejemplo para que puedas entenderlo mejor:

const edad = 25;
const mensaje = edad >= 18 ? "Eres mayor de edad" : "Eres menor de edad";
console.log(mensaje);

En este ejemplo, la condicion es edad >= 18. Si es verdadera, entonces se devuelve el valorSiVerdadero que es
"Eres mayor de edad" , de lo contrario se devuelve el valorSiFalso que es "Eres menor de edad" . En este caso,
la edad es mayor o igual a 18, por lo que se devuelve "Eres mayor de edad" .

Con varias condiciones:

let x = 5;
let resultado = (x > 10) ? "Mayor a 10" : (x > 5) ? "Mayor a 5" : "Menor o igual a 5";
console.log(resultado); // "Menor o igual a 5"

En este ejemplo, hay tres condiciones. Si la primera condición x > 10 es verdadera, el valor de resultado será
"Mayor a 10". De lo contrario, se evaluará la segunda condición x > 5. Si la segunda condición es verdadera,
el valor de resultado será "Mayor a 5". De lo contrario, el valor de resultado será "Menor o igual a 5".

let x = 3;
let resultado = (x > 10) ? "Mayor a 10" : (x > 5) ? "Mayor a 5" : (x > 2) ? "Mayor a 2" : "Menor o igual a 2";
console.log(resultado); // "Mayor a 2"

cuatro condiciones

let x = 3;
let resultado = (x > 10) ? "Mayor a 10" : (x > 5) ? "Mayor a 5" : (x > 2) ? "Mayor a 2" : "Menor o igual a 2";
console.log(resultado); // "Mayor a 2"

En este ejemplo, hay cuatro condiciones. Si la primera condición x > 10 es verdadera, el valor de resultado
será "Mayor a 10". De lo contrario, se evaluará la segunda condición x > 5. Si la segunda condición es
verdadera, el valor de resultado será "Mayor a 5". De lo contrario, se evaluará la tercera condición x > 2. Si la
tercera condición es verdadera, el valor de resultado será "Mayor a 2". De lo contrario, el valor de resultado
será "Menor o igual a 2".

OPERADOR SPREAD

El operador spread en JavaScript es un operador que se utiliza para descomponer los elementos de un
objeto iterable, como un array, en elementos individuales. Este operador se representa con tres puntos
consecutivos ( ... ) y se utiliza en diferentes contextos para realizar diversas tareas, como la copia de arrays,
la combinación de arrays, la definición de parámetros de función y la creación de objetos.

const array1 = [1, 2, 3];

const array2 = [...array1];
console.log(array2); // [1, 2, 3]

const array1 = [1, 2, 3];

const array2 = [4, 5, 6];
const combinedArray = [...array1, ...array2];
console.log(combinedArray); // [1, 2, 3, 4, 5, 6]

3. Definición de parámetros de función:

function sumNumbers(x, y, z) {
return x + y + z;
}
const numbers = [1, 2, 3];
console.log(sumNumbers(...numbers)); // 6

4. Creación de objetos:
const person = { name: 'John', age: 30 };
const address = { city: 'New York', country: 'USA' };
const personWithAddress = { ...person, ...address };
console.log(personWithAddress); // { name: 'John', age: 30, city: 'New York', country: 'USA' }

En resumen, el operador spread es una herramienta útil para manipular datos en JavaScript y se puede
utilizar en diferentes contextos para descomponer los elementos de un objeto iterable en elementos
individuales.

const obj1 = {a: 1, b: 2};

const obj2 = {c: 3, ...obj1};
console.log(obj2); // Output: {c: 3, a: 1, b: 2}

En este caso, el operador spread se utiliza para copiar los atributos del objeto obj1 en el nuevo objeto obj2,
de forma que obj2 contenga tanto los atributos de obj1 como los suyos propios.

OBJETOS NATIVOS EN JACASCRIPT

¡Claro! A continuación te doy una breve explicación y ejemplos de cada uno de los objetos nativos de JavaScript que
mencionaste:
 Object: es la base de todo objeto en JavaScript. Es el objeto principal y es utilizado para crear objetos
personalizados. Ejemplo:

let persona = { nombre: 'Juan', apellido: 'Pérez', edad: 30 };

 Array: es utilizado para almacenar varios valores en una sola variable. Es un objeto especializado para
almacenar elementos secuenciales. Ejemplo:
let numeros = [1, 2, 3, 4, 5];

 Boolean: es un objeto que representa un valor booleano, es decir, verdadero o falso. Ejemplo:
let esMayor = true;

 Date: es utilizado para trabajar con fechas y horas. Ejemplo:

let fechaActual = new Date();

 Error: es utilizado para manejar errores en JavaScript. Ejemplo:

throw new Error('Este es un mensaje de error');

 Function: es un objeto que permite definir funciones. Ejemplo:

function sumar(a, b) { return a + b; }

 JSON: es un objeto para trabajar con datos en formato JSON. Ejemplo:

let personaJSON = '{"nombre":"Juan", "apellido":"Pérez", "edad":30}'; let persona = JSON.parse(personaJSON);

 Map: es un objeto que almacena elementos en pares clave-valor y permite usar cualquier tipo de valor como
clave. Ejemplo:
let mapa = new Map(); mapa.set('nombre', 'Juan'); mapa.set('apellido', 'Pérez');
 Math: es un objeto que proporciona métodos matemáticos estáticos. Ejemplo:
let numeroAleatorio = Math.random();
 Number: es un objeto que representa valores numéricos. Ejemplo:
let numero = 42;
 Promise: es un objeto que representa la finalización (o falla) de una operación asíncrona y su valor resultante.
Ejemplo:
let promesa = new Promise(function(resolve, reject) { setTimeout(function() { resolve('¡Éxito!'); }, 2000); });
 Proxy: es un objeto que permite crear un objeto con un comportamiento personalizado. Ejemplo:
let objetoOriginal = {}; let objetoProxy = new Proxy(objetoOriginal, { get: function(target, property) { console.log('Se
accedió a la propiedad ' + property); return target[property]; } });
 RegExp: es un objeto que representa una expresión regular. Ejemplo:
let expresionRegular = /Hola, Mundo!/;
 Set: es un objeto que permite almacenar valores únicos de cualquier tipo, incluso valores primitivos y objetos
de referencia. Ejemplo:
 let set = new Set([1, 2, 3, 4, 5]);
 String: es un objeto que representa una cadena de texto. Ejemplo:
let mensaje = 'Hola, Mundo!';
 Symbol: es un objeto que representa un identificador único. Ejemplo:
let simbolo = Symbol('descripcion');
 WeakMap: es un objeto que permite almacenar pares clave-valor débiles, donde las claves solo se mantienen
mientras existan referencias al objeto. Ejemplo:
let objeto1

……………………..

1. getDate(): Devuelve el día del mes (de 1 a 31) para la fecha especificada.
const today = new Date(); const dayOfMonth = today.getDate(); console.log(dayOfMonth); // Output: 28
2. getDay(): Devuelve el día de la semana (de 0 a 6) para la fecha especificada.
const today = new Date(); const dayOfWeek = today.getDay(); console.log(dayOfWeek); //
Output: 4
3. getFullYear(): Devuelve el año (como un número de cuatro dígitos) para la fecha especificada.
const today = new Date(); const year = today.getFullYear(); console.log(year); // Output: 2023
4. getHours(): Devuelve las horas (de 0 a 23) para la fecha especificada.
const today = new Date(); const hours = today.getHours(); console.log(hours); // Output: 10
5. getMinutes(): Devuelve los minutos (de 0 a 59) para la fecha especificada.
const today = new Date(); const minutes = today.getMinutes(); console.log(minutes); // Output: 45
6. getSeconds(): Devuelve los segundos (de 0 a 59) para la fecha especificada.
const today = new Date(); const seconds = today.getSeconds(); console.log(seconds); // Output: 30
7. getTime(): Devuelve el número de milisegundos transcurridos desde el 1 de enero de 1970 hasta la fecha
especificada.
const today = new Date(); const timeInMs = today.getTime(); console.log(timeInMs); // Output: 1651218257102
8. toLocaleDateString(): Devuelve la fecha como una cadena en formato localizado de fecha.
const today = new Date(); const dateStr = today.toLocaleDateString(); console.log(dateStr); // Output: "4/28/2023"
(en formato MM/DD/YYYY)
9. toLocaleTimeString(): Devuelve la hora como una cadena en formato localizado de hora.

const today = new Date(); const timeStr = today.toLocaleTimeString(); console.log(timeStr); // Output: "10:50:22 AM"
(en formato de 12 horas)
10. toString(): Devuelve la fecha como una cadena en formato completo de fecha y hora.

const today = new Date(); const dateTimeStr = today.toString(); console.log(dateTimeStr); // Output: "Fri Apr 28 2023
10:54:30 GMT-0700 (Pacific Daylight Time)"
Ejemplos

For each
const miArray = [1, 2, 3, 4, 5];
miArray.forEach(function(elemento) {
console.log(elemento);
});
const miArray = [1, 2, 3, 4, 5];
miArray.forEach(elemento => {
console.log(elemento);
});
const miObjeto = {
valor: 2
};
const miArray = [1, 2, 3, 4, 5];
miArray.forEach(function(elemento) {
console.log(elemento * this.valor);
}, miObjeto);

MAP
El método map() en JavaScript devuelve un nuevo array con los resultados de aplicar una función a cada
elemento del array original. Aquí tienes un ejemplo:

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

const numerosDuplicados = numeros.map(function(numero) {
return numero * 2;
});
console.log(numerosDuplicados); // salida: [2, 4, 6, 8, 10]
En este ejemplo, map() se utiliza para duplicar cada elemento del array numeros . La función proporcionada
como argumento de map() toma un parámetro numero, que es el valor actual del array que se está iterando,
y devuelve numero * 2, que es el valor que se va a almacenar en el nuevo array numerosDuplicados . El
resultado final es un nuevo array que contiene los valores originales del array numeros duplicados.

FILTER:

el método filter() en JavaScript:

Supongamos que tenemos un arreglo de objetos con información de libros y queremos filtrar
aquellos cuyo autor sea "Gabriel García Márquez". Podríamos hacerlo de la siguiente manera:

const libros = [
{titulo: "Cien años de soledad", autor: "Gabriel García Márquez", publicacion: 1967},
{titulo: "El amor en los tiempos del cólera", autor: "Gabriel García Márquez", publicacion: 1985},
{titulo: "La ciudad y los perros", autor: "Mario Vargas Llosa", publicacion: 1963},
{titulo: "La casa verde", autor: "Mario Vargas Llosa", publicacion: 1966},
{titulo: "Rayuela", autor: "Julio Cortázar", publicacion: 1963},
];

const librosGarciaMarquez = libros.filter(libro => libro.autor === "Gabriel García Márquez");

console.log(librosGarciaMarquez);

En este ejemplo, el método filter() recorre cada objeto del arreglo libros y verifica si el valor de la propiedad
autor es igual a "Gabriel García Márquez". Si es así, ese objeto se añade al nuevo arreglo
librosGarciaMarquez que se genera como resultado de la operación. Finalmente, se imprime el nuevo
arreglo en la consola.

[
{titulo: "Cien años de soledad", autor: "Gabriel García Márquez", publicacion: 1967},
{titulo: "El amor en los tiempos del cólera", autor: "Gabriel García Márquez", publicacion: 1985},
]

REDUCE:

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

const suma = numeros.reduce((acumulador, numero) => acumulador + numero);
console.log(suma); // Resultado: 15

En este ejemplo, el método reduce() recibe una función que se ejecuta por cada elemento del array. Esta
función recibe dos parámetros: un acumulador y el elemento actual del array. En cada iteración, se suma el
elemento actual al acumulador y se retorna el resultado. Al finalizar la ejecución de la función reduce() , el
resultado final es la suma de todos los elementos del array.

PROMISE:
function loadImage(url) {
return new Promise((resolve, reject) => {
let img = new Image();
img.onload = () => resolve(img);
img.onerror = () => reject(new Error(`No se pudo cargar la imagen desde ${url}`));
img.src = url;
});
}
loadImage('https://example.com/image.jpg')
.then((img) => {
// Agregar la imagen al documento
document.body.appendChild(img);
})
.catch((error) => {
// Manejar el error
console.error(error);
});

En este ejemplo, se define una función loadImage que acepta una URL como parámetro y devuelve
una instancia de Promise. Dentro de la promesa, se crea un objeto de imagen y se asignan dos
manejadores de eventos onload y onerror . Si la imagen se carga correctamente, la promesa se
resuelve con el objeto de imagen. Si ocurre un error al cargar la imagen, la promesa se rechaza con
un objeto de error.
Luego, se llama a la función loadImage con una URL de imagen como parámetro. Se utiliza el
método then para agregar la imagen al documento si la promesa se resuelve correctamente. Si
ocurre un error, se maneja el error utilizando el método catch.

async/await:

Supongamos que tenemos una función getData() que realiza una solicitud a una API y devuelve una promesa
con los datos obtenidos. Podemos usar async/await para esperar a que se resuelva la promesa y manejar la
respuesta de manera asíncrona.
async function getDataAsync() {

try {
const response = await getData();
console.log(response);
} catch (error) {
console.error(error);
}
}
getDataAsync();

En este ejemplo, la función getDataAsync() se declara como async para poder usar la palabra clave await
dentro de ella. Luego, se llama a la función getData() usando await para esperar la resolución de la promesa
y obtener los datos de respuesta. La respuesta se almacena en la constante response y se muestra en la
consola. Si se produce algún error en la promesa, se maneja en el bloque catch. Finalmente, se llama a la
función getDataAsync() para iniciar el proceso asincrónico.

encodeURIComponent() y decodeURIComponent():
La función encodeURIComponent() se utiliza para codificar componentes de una URL y hacer que sean
válidos para ser utilizados en una solicitud HTTP. Por otro lado, decodeURIComponent() se utiliza para
decodificar un componente de una URL codificado previamente con encodeURIComponent() . Aquí te
presento un ejemplo de cómo utilizar ambas funciones:

// URL con un parámetro que necesita ser codificado

const url = 'https://ejemplo.com/buscar?q=perros y gatos';
// Codificar el parámetro usando encodeURIComponent()
const parametroCodificado = encodeURIComponent('perros y gatos');
// Crear una nueva URL con el parámetro codificado
const nuevaUrl = `https://ejemplo.com/buscar?q=${parametroCodificado}`;
console.log(nuevaUrl);
// Resultado: https://ejemplo.com/buscar?q=perros%20y%20gatos
// Decodificar el parámetro usando decodeURIComponent()
const parametroDecodificado = decodeURIComponent('perros%20y%20gatos');
console.log(parametroDecodificado);
// Resultado: perros y gatos

En este ejemplo, primero creamos una URL que contiene un parámetro q con el valor "perros y
gatos". Luego, utilizamos encodeURIComponent() para codificar ese valor, lo que resulta en "perros
%20y%20gatos" . Después, creamos una nueva URL con el valor codificado y la imprimimos en la
consola.

Finalmente, utilizamos decodeURIComponent() para decodificar el valor "perros%20y%20gatos" , lo que

devuelve el valor original "perros y gatos".

document.getElementById():
<body>
<div id="mi-elemento">Este es mi elemento</div>
<script>
// Acceder al elemento con id "mi-elemento"
const elemento = document.getElementById("mi-elemento");

// Modificar el contenido del elemento

elemento.textContent = "Este es el nuevo contenido del elemento";
</script>
document.getElementsByClassName():
<div class="frutas">
<p>Manzana</p>
<p>Pera</p>
</div>
<div class="frutas">
<p>Plátano</p>
<p>Naranja</p>
</div>
<div class="verduras">
<p>Zanahoria</p>
<p>Espinaca</p>
</div>
Y queremos seleccionar todos los elementos que tienen la clase "frutas" para modificar su contenido.
Podemos hacerlo de la siguiente manera en JavaScript:

const frutas = document.getElementsByClassName("frutas");

for (let i = 0; i < frutas.length; i++) {
const fruta = frutas[i];
const parrafos = fruta.getElementsByTagName("p");
for (let j = 0; j < parrafos.length; j++) {
const parrafo = parrafos[j];
parrafo.textContent = parrafo.textContent.toUpperCase();
}
}
document.getElementsByTagName():
<body>
<h1>Este es un encabezado h1</h1>
<p>Este es un párrafo.</p>
<div>
<h2>Este es un encabezado h2 dentro de un div</h2>
</div>
<ul>
<li>Elemento de lista 1</li>
<li>Elemento de lista 2</li>
<li>Elemento de lista 3</li>
</ul>
<p>Este es otro párrafo.</p>

const parrafos = document.getElementsByTagName('p');

Podemos obtener todos los elementos p en este documento y mostrar su contenido en la consola del
navegador de la siguiente manera:
for (let i = 0; i < parrafos.length; i++) {
console.log(parrafos[i].textContent);
}
const parrafos = document.getElementsByTagName('p');

for (let i = 0; i < parrafos.length; i++) {

console.log(parrafos[i].textContent);
}
Este código devuelve lo siguiente en la consola:
"Este es un párrafo."
"Este es otro párrafo."
También podemos obtener todos los elementos li en el documento y mostrar su contenido:
const itemsLista = document.getElementsByTagName('li');

for (let i = 0; i < itemsLista.length; i++) {

console.log(itemsLista[i].textContent);
}
"Elemento de lista 1"
"Elemento de lista 2"
"Elemento de lista 3"
document.querySelectorAll()

Claro, aquí te muestro un ejemplo de cómo utilizar document.querySelectorAll() para seleccionar todos los
elementos p dentro de un div y cambiarles el color de fondo:
<div id="mi-div">
<p>Primer párrafo</p>
<p>Segundo párrafo</p>
<p>Tercer párrafo</p>
</div>
const parrafos = document.querySelectorAll("#mi-div p");

parrafos.forEach(parrafo => {
parrafo.style.backgroundColor = "yellow";
});
En este ejemplo, primero se utiliza document.querySelectorAll("#mi-div p") para seleccionar todos los
elementos p dentro del div con el id mi-div . Luego, se utiliza forEach() para iterar sobre los elementos
seleccionados y cambiarles el color de fondo a amarillo.

array.slice():

El método slice() en JavaScript devuelve una copia de una porción de un array original en un nuevo
array. Toma dos parámetros opcionales: el índice de inicio y el índice de finalización (no incluido).
Si no se proporcionan, se devuelve una copia del array completo.

Aquí hay un ejemplo de uso de slice():

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

const newArray = originalArray.slice(1, 3); // devuelve un nuevo array que contiene los elementos [2, 3]
console.log(newArray); // [2, 3]

En este ejemplo, slice() toma el índice de inicio 1 y el índice de finalización 3, lo que significa que devuelve
una copia del array que incluye los elementos con índices 1 y 2 (pero no el elemento con índice 3). Esta
porción se copia en un nuevo array, que se asigna a newArray . Luego, console.log() se utiliza para imprimir el
nuevo array [2, 3].

array.splice():

let miArray = ["perro", "gato", "conejo", "loro", "pez"];

Para eliminar el elemento "conejo" del array, podemos utilizar el método splice() de la siguiente manera:

miArray.splice(2, 1);
console.log(miArray); // ["perro", "gato", "loro", "pez"]

La primera posición del método splice() indica el índice donde empezar la modificación, en este
caso, 2. La segunda posición indica cuántos elementos deben ser eliminados, en este caso, 1.

También podemos utilizar el método splice() para agregar elementos al array en cualquier posición.
Por ejemplo, para agregar el elemento "conejo" de nuevo al array, pero en la tercera posición,
podemos hacer lo siguiente:

miArray.splice(2, 0, "conejo");
console.log(miArray); // ["perro", "gato", "conejo", "loro", "pez"]

array.sort():

La primera posición del método splice() indica el índice donde empezar la modificación, en este caso, 2. La
segunda posición indica cuántos elementos deben ser eliminados, en este caso, 0. La tercera y siguientes
posiciones indican los elementos que deben ser agregados al array, en este caso, "conejo".
El método sort() ordena los elementos de un arreglo alfabética o numéricamente, y modifica el arreglo
original. Aquí hay un ejemplo de cómo se puede usar sort() para ordenar un arreglo de números de menor
a mayor:
const numeros = [5, 2, 7, 1, 8];
numeros.sort((a, b) => a - b);
console.log(numeros); // Output: [1, 2, 5, 7, 8]

En este ejemplo, sort() se llama en el arreglo numeros y se le pasa una función de comparación (a, b) => a - b.
La función de comparación toma dos argumentos a y b, y devuelve un número negativo si a es menor que
b, cero si son iguales, o un número positivo si a es mayor que b. La función de comparación se usa para
ordenar los elementos del arreglo en orden ascendente.

Object.keys() es un método de JavaScript que devuelve un array de las propiedades enumerables de un

objeto. Cada elemento del array es una cadena que representa el nombre de una propiedad del objeto.
Aquí te dejo un ejemplo sencillo:

const person = {
name: 'Juan',
age: 25,
city: 'Madrid'
};
const keys = Object.keys(person);
console.log(keys); // ["name", "age", "city"]

En este ejemplo, Object.keys() se utiliza para obtener un array con las propiedades del objeto person. Luego,
el array resultante se almacena en la variable keys. Finalmente, el array se muestra por consola.

const objeto = { a: 'uno', b: 'dos', c: 'tres' };

const entradas = Object.entries(objeto);
console.log(entradas); // Salida: [ [ 'a', 'uno' ], [ 'b', 'dos' ], [ 'c', 'tres' ] ]

Object.assign():

Object.assign() en JavaScript:

Supongamos que tenemos dos objetos obj1 y obj2, y queremos combinarlos en un nuevo objeto
obj3:

const obj1 = { a: 1 };
const obj2 = { b: 2, c: 3 };
const obj3 = Object.assign({}, obj1, obj2);
console.log(obj3); // { a: 1, b: 2, c: 3 }

const obj1 = { a: 1 };
const obj2 = { b: 2, c: 3 };
const obj3 = Object.assign({}, obj1, obj2);
console.log(obj3); // { a: 1, b: 2, c: 3 }

En este ejemplo, utilizamos Object.assign() para combinar los objetos obj1 y obj2 en un nuevo objeto obj3. El
primer parámetro de Object.assign() es el objeto de destino al que se asignarán los valores de los objetos de
origen, en este caso hemos pasado un objeto vacío {}. Luego, pasamos los objetos obj1 y obj2 como
argumentos adicionales, lo que significa que sus propiedades se copiarán en el objeto de destino en el
orden en que se pasaron como argumentos. Al imprimir obj3 en la consola, obtenemos el objeto

Object.create(): writable: true,

const persona = Object.create({}, { enumerable: true,
nombre: { configurable: true
value: "Juan", },
writable: true, sexo: {
enumerable: true, value: "Masculino",
configurable: true writable: true,
}, enumerable: true,
edad: { configurable: true
value: 25, }
});
En este ejemplo, creamos un objeto vacío {} como prototipo para el objeto persona. Luego,
pasamos un segundo argumento al método Object.create() que contiene las propiedades que
queremos agregar al objeto persona. Cada propiedad es un objeto con un value (valor), writable
(booleano que indica si la propiedad puede ser modificada), enumerable (booleano que indica si la
propiedad aparecerá en un bucle for-in) y configurable (booleano que indica si la propiedad puede
ser eliminada o si sus atributos pueden ser cambiados).

Con el objeto persona creado, podemos acceder a sus propiedades de la siguiente manera:

console.log(persona.nombre); // "Juan"
console.log(persona.edad); // 25
console.log(persona.sexo); // "Masculino"

string.slice():

const str = 'Este es un ejemplo de cadena';

const subStr = str.slice(5, 17);

console.log(subStr); // Resultado: "es un ejemplo"

En este ejemplo, string.slice() extrae la subcadena que comienza desde el quinto carácter (incluido) hasta el
decimoséptimo carácter (excluido) de la cadena str y la almacena en la variable subStr . Luego, la subcadena
se imprime en la consola utilizando console.log() .

string.substring():

La función substring() es una función nativa de JavaScript que devuelve una parte de una cadena de
texto, a partir del índice especificado.

La sintaxis es la siguiente: string.substring(indiceInicio, indiceFin) , donde indiceInicio es el índice a partir

del cual se debe comenzar a extraer la subcadena, y indiceFin es un índice opcional que indica el
final de la subcadena a extraer. Si indiceFin no se especifica, se extrae hasta el final de la cadena.

Aquí hay un ejemplo de cómo se puede usar substring() para extraer una subcadena de una cadena:

let str = "Hola mundo";

let subcadena = str.substring(0, 4);
console.log(subcadena); // "Hola"

En este ejemplo, la variable str contiene la cadena "Hola mundo" . Luego, la función substring() se usa para
extraer los primeros cuatro caracteres de la cadena (desde el índice 0 hasta el índice 3), que es la subcadena
"Hola". La subcadena se almacena en la variable subcadena y luego se imprime en la consola usando
console.log() .

date.toLocaleDateString():

const fecha = new Date('2022-06-01');

const opciones = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
const fechaFormateada = fecha.toLocaleDateString('es-ES', opciones);
console.log(fechaFormateada); // "miércoles, 1 de junio de 2022"

switch...case:

let opcion = 2;

switch(opcion) {
case 1:
console.log("La opción seleccionada es la 1");
break;
case 2:
console.log("La opción seleccionada es la 2");
 break;
case 3:
console.log("La opción seleccionada es la 3");
break;
default:
console.log("La opción seleccionada no es válida");
break;
}
En este ejemplo, la variable opcion tiene el valor de 2. Al utilizar switch(opcion) , se evalúan todos los case
hasta encontrar uno que sea igual al valor de opcion. En este caso, el case 2 es el que coincide y se ejecuta su
bloque de código, que imprime en consola "La opción seleccionada es la 2". El break se utiliza para salir del
switch y evitar que se evalúen los demás case. Si ninguno de los case coincide con el valor de la variable, se
ejecuta el bloque de código del default.

ASYNC/AWAIT

Supongamos que queremos hacer una llamada a una API y recuperar algunos datos. Podemos encapsular
esa llamada en una función que devuelva una Promise, de esta forma:
function getData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve([
{ id: 1, name: 'John' },
{ id: 2, name: 'Mary' },
{ id: 3, name: 'Adam' }
]);
}, 2000);
});
}

En este ejemplo, la función getData devuelve una Promise que resuelve después de dos segundos,
devolviendo un array de objetos. Ahora, podemos llamar a esta función desde otra función que utilice
async/await para esperar a que la Promise se resuelva antes de continuar:

async function fetchAndDisplayData() {

const data = await getData();
console.log(data);
// aquí podemos hacer algo con los datos obtenidos
}

En este ejemplo, la función fetchAndDisplayData utiliza la palabra clave await para esperar a que la
Promise devuelta por getData se resuelva antes de continuar. Una vez que se resuelve la Promise, la
variable data contiene el resultado, que podemos utilizar en el resto de la función.

Espero que esto te ayude a entender cómo utilizar Promises con async/await.