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

// push() - Inserta un elemento al final del array

array.push(6);

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

// pop() - Remueve un elemento del final del array

array.pop();

console.log(array); // [1, 2, 3, 4, 5]

// shift() - Remueve un elemento del inicio del array

array.shift();

console.log(array); // [2, 3, 4, 5]

// unshift() - Inserta un elemento al inicio del array

array.unshift(0);

console.log(array); // [0, 2, 3, 4, 5]

// slice() - Crea una copia de una parte del array

const sliceArray = array.slice(2, 4);

console.log(sliceArray); // [3, 4]
// concat() - Concatena dos o más arrays

const concatArray = array.concat([6, 7, 8]);

console.log(concatArray); // [0, 2, 3, 4, 5, 6, 7, 8]

// join() - Concatena todos los elementos del array en una cadena

console.log(array.join('-')); // 0-2-3-4-5

// filter() - Recorre el array y retorna un nuevo array con los elementos que cumplen una condición

const filterArray = array.filter((element) => element % 2 === 0);

console.log(filterArray); // [2, 4]

// map() - Recorre el array y modifica los elementos presentes en él, retornando un nuevo array
con la misma longitud que el original

const mapArray = array.map((element) => element * 2);

console.log(mapArray); // [0, 4, 6, 8, 10]

// reduce() - Recorre el array y aplica una función a cada elemento, retornando un valor final

const reduceArray = array.reduce((accumulator, element) => accumulator + element, 0);

console.log(reduceArray); // 15

// find() - Busca un elemento en el array y retorna el índice del elemento encontrado o -1 si no se

encuentra

const findIndex = array.findIndex((element) => element === 4);

console.log(findIndex); // 3

// some() - Verifica si al menos un elemento del array cumple una condición

const someArray = array.some((element) => element % 2 === 0);

console.log(someArray); // true
// every() - Verifica si todos los elementos del array cumplen una condición

const everyArray = array.every((element) => element % 2 === 0);

console.log(everyArray); // false

// includes() - Verifica si un elemento se encuentra en el array

const includesArray = array.includes(6);

console.log(includesArray); // true

// forEach() - Recorre el array y aplica una función a cada elemento

array.forEach((element) => console.log(element)); // 0 2 3 4 5

// Métodos de objetos básicos

// **constructor()**

// Crea un nuevo objeto

const object = new Object();

console.log(object); // {}

// **hasOwnProperty()**

// Verifica si un objeto tiene una propiedad

console.log(object.hasOwnProperty('name')); // false

// **isPrototypeOf()**

// Verifica si un objeto es el prototipo de otro objeto

console.log(Object.prototype.isPrototypeOf(object)); // true

// **propertyIsEnumerable()**

// Verifica si una propiedad de un objeto es enumerable

console.log(object.propertyIsEnumerable('name')); // false

// **toLocaleString()**

// Devuelve una representación localizable de un objeto

console.log(object.toLocaleString()); // {}

// **toString()**

// Devuelve una representación de cadena de un objeto

console.log(object.toString()); // Object {}

// Métodos de objetos avanzados

// **assign()**

// Copia las propiedades de un objeto a otro

const object1 = { name: 'Juan' };

const object2 = { age: 25 };

Object.assign(object2, object1);

console.log(object2); // { name: 'Juan', age: 25 }

// **keys()**

// Devuelve un array con las claves de un objeto

console.log(Object.keys(object2)); // ['name', 'age']

// **values()**
// Devuelve un array con los valores de un objeto

console.log(Object.values(object2)); // ['Juan', 25]

// **entries()**

// Devuelve un array con las parejas clave-valor de un objeto

console.log(Object.entries(object2)); // [['name', 'Juan'], ['age', 25]]

// **getOwnPropertyDescriptors()**

// Devuelve un objeto con los descriptores de propiedades de un objeto

console.log(Object.getOwnPropertyDescriptors(object2)); // { name: { value: 'Juan', writable: true,

enumerable: true, configurable: true }, age: { value: 25, writable: true, enumerable: true,
configurable: true } }

// **getOwnPropertyNames()**

// Devuelve un array con los nombres de las propiedades de un objeto

console.log(Object.getOwnPropertyNames(object2)); // ['name', 'age']

// **getOwnPropertySymbols()**

// Devuelve un array con los símbolos de las propiedades de un objeto

console.log(Object.getOwnPropertySymbols(object2)); // []

// **defineProperties()**

// Define propiedades en un objeto

Object.defineProperties(object2, {

newProperty: {

value: 'Hola',

writable: true,

enumerable: true,

configurable: true,

},
});

console.log(object2); // { name: 'Juan', age: 25, newProperty: 'Hola' }

// **defineProperty()**

// Define una propiedad en un objeto

Object.defineProperty(object2, 'newProperty2', {

value: 'Adiós',

writable: false,

enumerable: false,

configurable: false,

});

console.log(object2); // { name: 'Juan', age: 25, newProperty: 'Hola', newProperty2: 'Adiós' }

// **seal()**

// Impide la modificación de las propiedades de un objeto

Object.seal(object2);

// **freeze()**

// Impide la modificación de las propiedades de un objeto y la adición de nuevas propiedades

Object.freeze(object2);

// **preventExtensions()**

// Impide la adición de nuevas propiedades a un objeto

Object.preventExtensions(object2);

// **isSealed()**

// Verifica si un objeto está sellado

console.log(Object.isSealed(object2)); // true
// **isFrozen()**

// Verifica si un objeto está congelado

console.log(Object.isFrozen(object2)); // true

// **isExtensible()**

// Verifica si un objeto es extensible

console.log(Object.isExtensible(object2)); // false

// Métodos de cadena básicos

// **charAt()**

// Devuelve el carácter en la posición especificada

const string = 'Hola, mundo';

console.log(string.charAt(0)); // H

// **charCodeAt()**

// Devuelve el código Unicode del carácter en la posición especificada

console.log(string.charCodeAt(0)); // 72

// **concat()**

// Concatena una o más cadenas

console.log(string.concat('!')); // Hola, mundo!

// **indexOf()**

// Devuelve el índice de la primera aparición de una subcadena

console.log(string.indexOf('mundo')); // 6

// **lastIndexOf()**

// Devuelve el índice de la última aparición de una subcadena

console.log(string.lastIndexOf('mundo')); // 6

// **length**

// Devuelve la longitud de la cadena

console.log(string.length); // 11

// **localeCompare()**

// Compara dos cadenas de acuerdo con la configuración regional actual

console.log(string.localeCompare('Hola, mundo!')); // 0

// **match()**

// Devuelve un array con las coincidencias de una expresión regular

const regex = /[a-z]/;

console.log(string.match(regex)); // ["H"]

// **replace()**

// Reemplaza todas las ocurrencias de una subcadena con otra subcadena

console.log(string.replace('mundo', 'universo')); // Hola, universo

// **slice()**

// Devuelve una subcadena de la cadena

console.log(string.slice(0, 5)); // Hola

// **split()**

// Divide la cadena en subcadenas según una expresión regular

console.log(string.split(' ')); // ["Hola", "mundo"]

// **substr()**

// Devuelve una subcadena de la cadena, comenzando en la posición especificada

console.log(string.substr(0, 5)); // Hola

// **substring()**

// Devuelve una subcadena de la cadena, comenzando en la posición especificada y terminando en

la posición especificada

console.log(string.substring(0, 5)); // Hola

// **toLocaleString()**

// Devuelve una representación localizable de la cadena

console.log(string.toLocaleString()); // Hola, mundo

// **toString()**

// Devuelve una representación de cadena de la cadena

console.log(string.toString()); // Hola, mundo

// **trim()**

// Elimina los espacios en blanco del principio y del final de la cadena

console.log(string.trim()); // Hola, mundo

// Métodos de cadena avanzados

// **codePointAt()**
// Devuelve el código Unicode del carácter en la posición especificada

console.log(string.codePointAt(0)); // 72

// **endsWith()**

// Verifica si la cadena termina con una subcadena

console.log(string.endsWith('mundo')); // true

// **includes()**

// Verifica si la cadena contiene una subcadena

console.log(string.includes('mundo')); // true

// **repeat()**

// Repite la cadena un número determinado de veces

console.log(string.repeat(3)); // Hola, mundoHola, mundoHola, mundo

// **startsWith()**

// Verifica si la cadena comienza con una subcadena

console.log(string.startsWith('Hola')); // true

// **toSource()**

// Devuelve una representación del código fuente de la cadena

console.log(string.toSource()); // "'Hola, mundo'"

// **toUpperCase()**

// Convierte todos los caracteres de la cadena a mayúsculas

console.log(string.toUpperCase()); // HOLA, MUNDO

// **toLowerCase()**

// Convierte todos los caracteres de la cadena a minúsculas

console.log(string.toLowerCase()); // hola, mundo