All questions

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

`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.trim` removes whitespace from both ends of a string, but does not affect whitespace in the middle of the string. 

const str = '  hello  ';
const trimmed = str.trim();
console.log(trimmed); // 'hello'

`String.prototype.toUpperCase` returns a new string with all characters converted to uppercase. 

const str = 'hello';
const upper = str.toUpperCase();
console.log(upper); // 'HELLO'

`String.prototype.toLowerCase` returns a new string with all characters converted to lowercase. 

const str = 'HELLO';
const lower = str.toLowerCase();
console.log(lower); // 'hello'

`String.prototype.charAt` returns the character at a specified index in a string. If the index is out of range, it returns an empty string. 

const str = 'hello';
const char = str.charAt(1);
console.log(char); // 'e'

`String.prototype.indexOf` returns the index of the first occurrence of a specified value in a string. If the value is not found, it returns -1. 

const str = 'hello';
const index = str.indexOf('l');
console.log(index); // 2

`String.prototype.slice` extracts a section of a string and returns it as a new string, without modifying the original string. 

const str = 'hello';
const sliced = str.slice(1, 4);
console.log(sliced); // 'ell'

`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