OR questions

`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, replacing, or adding elements at a specified index. It modifies the original array and returns an array of removed elements. 

const arr = [1, 2, 3];
arr.splice(1, 1, 'a', 'b');
console.log(arr); // [1, 'a', 'b', 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.join` joins all elements of an array into a string, with elements separated by a specified separator. The default separator is a comma if none is provided. 

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

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. By default, the elements are sorted as strings. A custom sorting function can be provided for different sorting logic. 

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

`Array.prototype.from` creates a new array instance from an array-like or iterable object. It can also take a map function to modify the elements while creating the new array. 

const arrLike = { length: 3, 0: 'a', 1: 'b', 2: 'c' };
const arr = Array.from(arrLike);
console.log(arr); // ['a', 'b', 'c']

`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.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.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.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.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.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]

`Array.prototype.toLocaleString` returns a string representing the array and its elements, formatted according to the locale and options. It uses the `toLocaleString` method of each element. 

const arr = [1, 2, 3];
console.log(arr.toLocaleString()); // '1,2,3' (may vary depending on locale)

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. By default, elements are sorted as strings. A custom sorting function can be used to specify the sort order. 

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

`String.prototype.split` splits a string into an array of substrings based on a specified separator. The separator can be a string or regular expression. 

const str = 'a,b,c';
const arr = str.split(',');
console.log(arr); // ['a', 'b', 'c']

`String.prototype.replace` replaces the first occurrence of a substring or pattern (regular expression) with a new substring. To replace all occurrences, a global regular expression must be used. 

const str = 'hello world';
const newStr = str.replace('world', 'JavaScript');
console.log(newStr); // 'hello JavaScript'

`String.prototype.includes` checks if a string contains a specified substring. It returns `true` if the substring is found, otherwise `false`. 

const str = 'hello';
console.log(str.includes('ell')); // true
console.log(str.includes('world')); // false

`String.prototype.search` searches a string for a match against a regular expression and returns the index of the first match. If no match is found, it returns -1. 

const str = 'hello 123'; 
const index = str.search(/\d+/); 
console.log(index); // 6 

`String.prototype.repeat` returns a new string with the specified number of copies of the original string, concatenated together. 

const str = 'abc';
const repeated = str.repeat(3);
console.log(repeated); // 'abcabcabc'