Javascript Questions

`Array.prototype.concat` merges two or more arrays into a new array. It does not modify the original arrays and can take any number of arguments, including arrays and values. 

const arr1 = [1, 2];
const arr2 = [3, 4];
const merged = arr1.concat(arr2);
console.log(merged); // [1, 2, 3, 4]

`Array.prototype.toString` returns a string representation of the array by concatenating its elements with commas. It does not modify the original array. 

const arr = [1, 2, 3];
console.log(arr.toString()); // '1,2,3'

`Array.prototype.unshift` adds one or more elements to the beginning of an array and returns the new length of the array. It modifies the original array. 

const arr = [2, 3];
arr.unshift(1);
console.log(arr); // [1, 2, 3]

`Array.prototype.pop` removes the last element from an array and returns that element. It modifies the original array. 

const arr = [1, 2, 3];
const last = arr.pop();
console.log(last); // 3
console.log(arr); // [1, 2]

`Array.prototype.shift` removes the first element from an array and returns that element. It modifies the original array and shifts all subsequent elements down by one. 

const arr = [1, 2, 3];
const first = arr.shift();
console.log(first); // 1
console.log(arr); // [2, 3]

`Array.prototype.entries` returns a new Array Iterator object that contains the key/value pairs for each index in the array. It allows iteration over the array's indices and values. 

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

`Array.prototype.keys` returns a new Array Iterator object that contains the keys (indices) for each index in the array. It allows iteration over the array's indices. 

const arr = ['a', 'b', 'c'];
const iterator = arr.keys();
for (const key of iterator) {
  console.log(key);
}
// Output:
// 0
// 1
// 2

`Array.prototype.values` returns a new Array Iterator object that contains the values for each index in the array. It allows iteration over the array's values. 

const arr = ['a', 'b', 'c'];
const iterator = arr.values();
for (const value of iterator) {
  console.log(value);
}
// Output:
// 'a'
// 'b'
// 'c'

`Array.prototype.flatMap` maps each element using a provided mapping function and then flattens the resulting array into a new array. It combines the map and flat operations into a single method. 

const arr = [1, 2, 3];
const flatMapArr = arr.flatMap(x => [x, x * 2]);
console.log(flatMapArr); // [1, 2, 2, 4, 3, 6]

`Array.prototype.reduce` executes a reducer function on each element of the array, accumulating a single result. It takes a callback function and an optional initial value, and returns the final accumulated result. 

const arr = [1, 2, 3];
const sum = arr.reduce((acc, num) => acc + num, 0);
console.log(sum); // 6

`Array.prototype.map` creates a new array with the results of calling a provided function on every element in the calling array. It does not modify the original array. 

const arr = [1, 2, 3];
const doubled = arr.map(num => num * 2);
console.log(doubled); // [2, 4, 6]

`Array.prototype.filter` creates a new array with all elements that pass a provided test function. It does not modify the original array. 

const arr = [1, 2, 3, 4];
const evens = arr.filter(num => num % 2 === 0);
console.log(evens); // [2, 4]

`Array.prototype.forEach` executes a provided function once for each element in the array. It does not return a value and does not modify the original array. 

const arr = [1, 2, 3];
arr.forEach(num => console.log(num));
// Output:
// 1
// 2
// 3

`Array.prototype.some` tests whether at least one element in the array passes a provided test function. It returns `true` if at least one element satisfies the condition, otherwise `false`. It does not modify the original array. 

const arr = [1, 2, 3];
const hasEven = arr.some(num => num % 2 === 0);
console.log(hasEven); // true

`Array.prototype.every` tests whether all elements in the array pass a provided test function. It returns `true` if all elements pass the test, otherwise `false`. It does not modify the original array. 

const arr = [2, 4, 6];
const allEven = arr.every(num => num % 2 === 0);
console.log(allEven); // true

`Array.prototype.includes` determines whether an array contains a certain value among its entries. It returns `true` if the array contains the value, otherwise `false`. 

const arr = [1, 2, 3];
console.log(arr.includes(2)); // true
console.log(arr.includes(4)); // false

`Array.prototype.splice` changes the contents of an array by removing or replacing existing elements and/or adding new elements in place. It modifies the original array and returns an array containing the removed elements. 

const arr = [1, 2, 3, 4];
const removed = arr.splice(1, 2, 'a', 'b');
console.log(arr); // [1, 'a', 'b', 4]
console.log(removed); // [2, 3]

`Array.prototype.fill` changes all elements in an array to a static value from a start index to an end index. It modifies the original array. 

const arr = [1, 2, 3];
arr.fill(0, 1, 3);
console.log(arr); // [1, 0, 0]

`Array.prototype.reverse` reverses the elements of an array in place and returns the reversed array. It modifies the original array. 

const arr = [1, 2, 3];
arr.reverse();
console.log(arr); // [3, 2, 1]

`Array.prototype.flat` creates a new array with all sub-array elements concatenated into it recursively up to a specified depth. It can flatten nested arrays to a specified level. 

const arr = [1, [2, [3, [4]]]];
const flatArr = arr.flat(2);
console.log(flatArr); // [1, 2, 3, [4]]

`Array.prototype.join` joins all elements of an array into a string separated by a specified separator. The default separator is a comma. 

const arr = ['a', 'b', 'c'];
const joined = arr.join('-');
console.log(joined); // 'a-b-c'

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. By default, it sorts elements as strings. A custom comparator function can be provided to sort elements in other ways. 

const arr = [3, 1, 2];
arr.sort();
console.log(arr); // [1, 2, 3]

`Array.prototype.concat` merges two or more arrays into a new array. It does not modify the original arrays and can take any number of arguments, including arrays and values. 

const arr1 = [1, 2];
const arr2 = [3, 4];
const merged = arr1.concat(arr2);
console.log(merged); // [1, 2, 3, 4]

`Array.prototype.slice` returns a shallow copy of a portion of an array into a new array object selected from start to end (end not included). It does not modify the original array. 

const arr = [1, 2, 3, 4];
const sliced = arr.slice(1, 3);
console.log(sliced); // [2, 3]

`Array.prototype.splice` changes the contents of an array by removing or replacing existing elements and/or adding new elements in place. It modifies the original array and returns an array containing the removed elements. 

const arr = [1, 2, 3, 4];
const removed = arr.splice(2, 1, 'a', 'b');
console.log(arr); // [1, 2, 'a', 'b', 4]
console.log(removed); // [3]