All questions

`Array.prototype.indexOf` returns the index of the first occurrence of a specified element within the array. If the element is not found, it returns `-1`. It performs a strict comparison (===). 

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

`Array.prototype.sort` sorts the elements of an array in place and returns the sorted array. The sorting is based on the UTF-16 code units of the elements by default, but can be customized with a comparison function. 

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

`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.copyWithin` shallow copies a portion of the array to another location within the same array. It modifies the original array and returns the modified array. 

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

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

`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.localeCompare` compares two strings in the current locale and returns a number indicating whether the calling string comes before, after, or is equal to the compared string. 

const str1 = 'apple';
const str2 = 'banana';
const result = str1.localeCompare(str2);
console.log(result); // -1 (str1 is less than str2)

`String.prototype.fontcolor` returns a string wrapped in HTML `<font>` tags with a specified color. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const coloredStr = str.fontcolor('red');
console.log(coloredStr); // '<font color="red">hello</font>'

`String.prototype.fontsize` returns a string wrapped in HTML `<font>` tags with a specified size. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const sizedStr = str.fontsize(7);
console.log(sizedStr); // '<font size="7">hello</font>'

`String.prototype.anchor` creates an HTML `<a>` element wrapping the string with a specified name attribute. This method is deprecated and should not be used in modern applications. 

const str = 'Click here';
const anchoredStr = str.anchor('top');
console.log(anchoredStr); // '<a name="top">Click here</a>'

`String.prototype.small` returns a string wrapped in HTML `<small>` tags. This method is deprecated and should not be used in modern applications. 

const str = 'hello';
const smallStr = str.small();
console.log(smallStr); // '<small>hello</small>'

`Array.isArray` determines whether a value is an array. It returns `true` if the value is an array, otherwise `false`. 

console.log(Array.isArray([1, 2, 3])); // true
console.log(Array.isArray({})); // false

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

`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.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.concat` combines multiple strings into one string. It does not modify the original strings but returns a new concatenated string. 

const str1 = 'hello';
const str2 = 'world';
const combined = str1.concat(' ', str2);
console.log(combined); // 'hello world'

`String.prototype.substr` extracts a substring from a string based on a starting index and length. It returns the extracted substring. 

const str = 'hello world';
const substr = str.substr(6, 5);
console.log(substr); // 'world'

`Array.prototype.find` returns the first element in the array that satisfies the provided testing function. If no elements satisfy the function, it returns `undefined`. It does not modify the original array. 

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

`Array.prototype.reduceRight` executes a reducer function on each element of the array from right to left, accumulating a single result. It is similar to `reduce`, but processes elements in reverse order. 

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

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

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