Array_methods1.txt

Array.at()  /  Array.concat()  /  Array.copyWithin()  /  Array.entries()  /  Array.every()


//  Array.at() 
Array.prototype.at()

    - at() method takes an integer value and returns the item at that index
    - Negative integers count back from the last item
    - Always returns undefined if index < -array.length or index >= array.length
  
  const array1 = [5, 12, 8, 130, 44];

  let index = 2;

  console.log(`Using an index of ${index} the item returned is ${array1.at(index)}`);
  // expected output: "Using an index of 2 the item returned is 8"

  index = -2;

  console.log(`Using an index of ${index} item returned is ${array1.at(index)}`);
  // expected output: "Using an index of -2 item returned is 130"
  ------------------
  
  // A function which returns the last item of a given array
  function returnLast(arr) {
  return arr.at(-1);
  }
  const cart = ["apple", "banana", "pear"];
  // Get the last item of our array 'cart'
  const item1 = returnLast(cart);
  console.log(item1); // 'pear'
  
Similarly:
 -  // Using length property
    const lengthWay = colors[colors.length - 2];
    console.log(lengthWay); // 'green'

  -  // Using slice() method. Note an array is returned
      const sliceWay = colors.slice(-2, -1);
      console.log(sliceWay[0]); // 'green'

  -  // Using at() method
    const atWay = colors.at(-2);
    console.log(atWay); // 'green'
    
============================================================================
 
 // Array.prototype.concat()
 const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3);
// expected output: Array ["a", "b", "c", "d", "e", "f"]
const alphaNumeric = array1.concat(1, [2, 3]);

console.log(alphaNumeric);
// results in ['a', 'b', 'c', 1, 2, 3]

//
    - [Symbol.isConcatSpreadable]: true will only be cancat as array:
    
const obj1 = { 0: 1, 1: 2, 2: 3, length: 3 };
const obj2 = { 0: 1, 1: 2, 2: 3, length: 3, [Symbol.isConcatSpreadable]: true };
console.log([0].concat(obj1, obj2));
// [ 0, { '0': 1, '1': 2, '2': 3, length: 3 }, 1, 2, 3 ]
 const arrayLike = { [Symbol.isConcatSpreadable]: true, length: 2, 0: 1, 1: 2 };
console.log(Array.prototype.concat.call(arrayLike, 3, 4)); // [1, 2, 3, 4]
 
 
======================================================================================\

// Array.prototype.copyWithin()
make shallow copies part of an array to another location in
the same array and returns it without modifying its length.

copyWithin(target, start, end) // Syntax
Negative index counts back from the end of the array 

const array1 = ['a', 'b', 'c', 'd', 'e'];

// copy to index 0 the element at index 3
console.log(array1.copyWithin(0, 3, 4));
// expected output: Array ["d", "b", "c", "d", "e"]

// copy to index 1 all elements from index 3 to the end
console.log(array1.copyWithin(1, 3));
// expected output: Array ["d", "d", "e", "d", "e"]

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

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

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

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

console.log([1, , 3].copyWithin(2, 1, 2)); // [1, empty, empty]

const arrayLike = {
            length: 5,
            3: 1,
            };
console.log(Array.prototype.copyWithin.call(arrayLike, 0, 3));
// { '0': 1, '3': 1, length: 5 }
console.log(Array.prototype.copyWithin.call(arrayLike, 3, 1));
// { '0': 1, length: 5 }
// The '3' property is deleted because the copied source is an empty slot

=======================================================================================

// Array.prototype.entries()
method returns a new Array Iterator object that contains the key/value pairs for each index in the array.

const a = ["a", "b", "c"];
for (const [index, element] of a.entries()) {
  console.log(index, element);
}
// 0 'a'
// 1 'b'
// 2 'c'

===========================================================================================

// Array.prototype.every()
method tests whether all elements in the array pass the test implemented by the provided function.
It returns a Boolean value.
const isBelowThreshold = (currentValue) => currentValue < 40;

const array1 = [1, 30, 39, 29, 10, 13];

console.log(array1.every(isBelowThreshold));
// expected output: true

Syntax
// Arrow function
every((element) => { /* … */ })
every((element, index) => { /* … */ })
every((element, index, array) => { /* … */ })

// Callback function
every(callbackFn)
every(callbackFn, thisArg)

// Inline callback function
every(function (element) { /* … */ })
every(function (element, index) { /* … */ })
every(function (element, index, array) { /* … */ })
every(function (element, index, array) { /* … */ }, thisArg)

callbackFn
A function to execute for each element in the array. 
It should return a truthy to indicate the element passes the test, and a falsy value 
otherwise.
every() does not mutate the array on which it is called, but the function provided as callbackFn can.

// Testing size of all array elements
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough); // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

/// Check if one array is a subset of another array
const isSubset = (array1, array2) =>
  array2.every((element) => array1.includes(element));

console.log(isSubset([1, 2, 3, 4, 5, 6, 7], [5, 7, 6])); // true
console.log(isSubset([1, 2, 3, 4, 5, 6, 7], [5, 8, 7])); // false

// ---------------
// Modifying items
// ---------------
let arr = [1, 2, 3, 4];
arr.every((elem, index, arr) => {
  arr[index + 1]--;
  console.log(`[${arr}][${index}] -> ${elem}`);
  return elem < 2;
});

// Loop runs for 3 iterations, but would
// have run 2 iterations without any modification
//
// 1st iteration: [1,1,3,4][0] -> 1
// 2nd iteration: [1,1,2,4][1] -> 1
// 3rd iteration: [1,1,2,3][2] -> 2

// ---------------
// Appending items
// ---------------
arr = [1, 2, 3];
arr.every((elem, index, arr) => {
  arr.push("new");
  console.log(`[${arr}][${index}] -> ${elem}`);
  return elem < 4;
});

// Loop runs for 3 iterations, even after appending new items
//
// 1st iteration: [1, 2, 3, new][0] -> 1
// 2nd iteration: [1, 2, 3, new, new][1] -> 2
// 3rd iteration: [1, 2, 3, new, new, new][2] -> 3

// ---------------
// Deleting items
// ---------------
arr = [1, 2, 3, 4];
arr.every((elem, index, arr) => {
  arr.pop();
  console.log(`[${arr}][${index}] -> ${elem}`);
  return elem < 4;
});

// Loop runs for 2 iterations only, as the remaining
// items are `pop()`ed off
//
// 1st iteration: [1,2,3][0] -> 1
// 2nd iteration: [1,2][1] -> 2