Los métodos son fns que se pueden invocar en objetos
Los arreglos son objetos, por lo tanto también tienen métodos en JS.

segmento (comienzo): extrae parte de la matriz en una nueva matriz, sin mutar la matriz original.

let arr = ['a','b','c','d','e'];

// Usecase: Extract till index passed as argument
arr.slice(2); // [ 'c', 'd', 'e' ]

// Usecase: Extract from [first index] to [second index-1] value.
arr.slice(2,4); // [ 'c', 'd' ] i.e Length of array will be end-begin or 4-2 = 2 

// Usecase: Extract last 2 elements
arr.slice(-2); // [ 'd', 'e' ]

// Usecase: Extract the last element.
arr.slice(-1);  // [ 'e' ]  

// Usecase: Extract from index passed to leaving the last two elements.
arr.slice(1,-2);  // [ 'e' ]  

// Usecase: Create a shallow copy of an array
arr.slice(); // 1st way
[...arr]; // 2nd way

// Caso de uso: extraer del valor [primer índice] al [segundo índice-1]. arr.slice(2,4); //

es decir, la longitud de la matriz será final-comienzo o 4-2 = 2 // Caso de uso: extraer los últimos 2 elementos arr.slice(-2); // ['d', 'e'] // Caso de uso: extrae el último elemento. arr.slice(-1); // ['e'] // Caso de uso: extracto del índice pasado para dejar los dos últimos elementos. arr.slice(1,-2); // ['e'] // Caso de uso: crear una copia superficial de una matriz arr.slice(); // 1er camino [...arr]; // 2do camino

// splice: remove the elements begining from the index passed. Mutates the orig. array.
// returns: part of the removed array
let arr = ['a','b','c','d','e'];
// arr.splice(2); // [ 'c', 'd', 'e' ]
// arr; // [ 'a', 'b' ]

// Usecase: Remove last element of the array
// arr.splice(-1); // [ 'e' ]
// arr; // [ 'a', 'b', 'c', 'd' ]

// Usecase: Delete no of elements. splice(index, deleteCount)
arr.splice(1, 3); // [ 'b', 'c', 'd' ]
arr; // [ 'a', 'e' ]

// empalme: elimina los elementos a partir del índice pasado. Muta el orig. formación. // devuelve: parte de la matriz eliminada let arr = ['a','b','c','d','e']; // arr.splice(2); //

// llegada; // ['a', 'b'] // Caso de uso: eliminar el último elemento de la matriz // arr.splice(-1); // ['e'] // llegada; //

// Caso de uso: eliminar el número de elementos. empalme(índice, eliminarContar) arr.empalme(1, 3); //
llegar; // ['a', 'e']

let arr = ['a','b','c','d','e'];
let arr2 = arr.reverse();
arr;
arr2;

devuelve: matriz invertida

let arr = ['a','b','c','d','e']; let arr2 = arr.reverse(); llegar; arr2;

let arr1 = ['a','b','c','d','e'];
let arr2 = ['f','g','h','i','j'];

[...arr1, ...arr2];       // 1st way
arr2 = arr1.concat(arr2); // 2nd way

devuelve: matriz unida

let arr1 = ['a','b','c','d','e']; let arr2 = ['f','g','h','i','j']; [...arr1, ...arr2]; // 1er camino arr2 = arr1.concat(arr2); // 2do camino

let arr1 = ['a','b','c','d','e'];
let arr2 = ['f','g','h','i','j'];
const x = arr1.concat(arr2);
x.join('-'); // 'a-b-c-d-e-f-g-h-i-j'

devuelve: matriz unida

let arr1 = ['a','b','c','d','e']; let arr2 = ['f','g','h','i','j']; constante x = arr1.concat(arr2); x.join('-'); // 'a-b-c-d-e-f-g-h-i-j'

"A medida que pase el tiempo, los recordarás según su uso."

let arr = ['a','b','c','d','e'];

arr[0];    // 1st way
arr.at(0); // 2nd way

// Get the last element of the array
arr[arr.length - 1];  // 1st way
arr.slice(-1)[0];     // 2nd way
arr.at(-1);           // 3rd way

arr.at(0); // 'a'
arr.at(-1); // 'e'

Admite encadenamiento de métodos. Funciona en matrices, cadenas

// Looping over array using forEach method.
let account = [2000,-300, 400, -200, -500,  1000, -300];

// Loop over an array using for-of
for(let money of account){
  if(money > 0){
    console.log(`Deposited ${money}`);
  } else {
    console.log(`Withdrawn ${Math.abs(money)}`);
  }
}

// .entries(): returns an array of arrays.
// return the output as index-value pair.
// first element must be index, second element must be element-value
for(let [i,money] of account.entries()){
  if(money > 0){
    console.log(`Transaction ${i 1}, Deposited ${money}`);
  } else {
    console.log(`Transaction ${i 1}, Withdrawn ${Math.abs(money)}`);
  }
}

// Loop over an array using forEach which requires a callback fn.
// forEach will call the callback fn, and not we.
// forEach will pass each element as argument in every iteration.
account.forEach(function(money){
  if(money > 0){
    console.log(`Deposited ${money}`);
  } else {
    console.log(`Withdrawn ${Math.abs(money)}`);
  }
});
// Iteration 1: pass arg1 to CB-fn(arg1)
// Iteration 2: pass arg2 to CB-fn(arg2)
// Iteration 3: pass arg3 to CB-fn(arg3)
// .....
// .....


// forEach will pass each element, index, array as argument in every iteration. Order of arguments matter, not the no of these arguments i.e first element should be the current-Element, second element should be index, third element should be entire array which is being looped-over.
// first element must be element-value, second element should be index, third element must be entire array. This is how its different from array.entries()
account.forEach(function(money, i, arr){
  if(money > 0){
    console.log(`Transaction ${i 1}, Deposited ${money} into ${arr}`);
  } else {
    console.log(`Transaction ${i 1}, Withdrawn ${Math.abs(money)} from ${arr}`);
  }
});

para cada uno:

// Recorriendo la matriz usando el método forEach. dejar cuenta = [2000,-300, 400, -200, -500, 1000, -300]; // Recorre una matriz usando for-of for(dejar dinero de la cuenta){ si(dinero > 0){ console.log(`${dinero} depositado`); } demás { console.log(`Retirado ${Math.abs(dinero)}`); } } // .entries(): devuelve una matriz de matrices. // devuelve la salida como par índice-valor. // el primer elemento debe ser índice, el segundo elemento debe ser valor-elemento for(let [i,dinero] de cuenta.entradas()){ si(dinero > 0){ console.log(`Transacción ${i 1}, ${dinero depositado}`); } demás { console.log(`Transacción ${i 1}, Retirado ${Math.abs(money)}`); } } // Recorre una matriz usando forEach que requiere una devolución de llamada fn. // forEach llamará a la devolución de llamada fn, no a nosotros. // forEach pasará cada elemento como argumento en cada iteración. cuenta.forEach(función(dinero){ si(dinero > 0){ console.log(`${dinero} depositado`); } demás { console.log(`Retirado ${Math.abs(dinero)}`); } }); // Iteración 1: pasar arg1 a CB-fn(arg1) // Iteración 2: pasar arg2 a CB-fn(arg2) // Iteración 3: pasar arg3 a CB-fn(arg3) // ..... // ..... // forEach pasará cada elemento, índice, matriz como argumento en cada iteración. El orden de los argumentos importa, no el número de estos argumentos, es decir, el primer elemento debe ser el elemento actual, el segundo elemento debe ser el índice, el tercer elemento debe ser la matriz completa que se está recorriendo. // el primer elemento debe ser valor de elemento, el segundo elemento debe ser índice, el tercer elemento debe ser la matriz completa. Así es como se diferencia de array.entries() cuenta.forEach(función(dinero, i, arr){ si(dinero > 0){ console.log(`Transacción ${i 1}, ${money} depositado en ${arr}`); } demás { console.log(`Transacción ${i 1}, Retirado ${Math.abs(money)} de ${arr}`); } });

Cuándo utilizar for-of y forEach:

forEach: No se puede salir de él. continuar-romper no funciona dentro de él. Siempre recorrerá toda la matriz y no se podrá hacer nada para detenerlo. for-of: Se utiliza cuando necesitamos salir del array.

"A medida que practiques más y más, mejorarás tus habilidades."