IF questions

In JavaScript, `JSON.parse()` is used to convert a JSON string into a JavaScript object, while `JSON.stringify()` is used to convert a JavaScript object into a JSON string. These methods are essential for working with JSON data, enabling the exchange of data between servers and web applications.

Static Site Generation (SSG) in Next.js generates HTML at build time, resulting in fast, static pages. Server-Side Rendering (SSR) generates HTML on each request, providing up-to-date content. SSG is ideal for content that doesn't change frequently, while SSR is better for dynamic content that needs to reflect real-time data.

In Next.js, static routes are defined by creating files in the `pages` directory, each representing a specific route. Dynamic routes are created by using square brackets in the file name (e.g., `[id].js`), allowing the route to match any value. Static routes are used for fixed paths, while dynamic routes handle variable segments.

`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.includes` checks if an array contains a specified element and returns `true` if it is found, otherwise `false`. It is case-sensitive and supports an optional starting index. 

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

`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.lastIndexOf` returns the index of the last occurrence of a specified element within the array. If the element is not found, it returns `-1`. It performs a strict comparison (===). 

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

`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.flat` creates a new array with all sub-array elements concatenated into it recursively up to the specified depth. It helps to flatten nested arrays into a single array. 

const arr = [1, [2, [3, [4]]]];
const flatArr = arr.flat(2);
console.log(flatArr); // [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.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.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'

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

`String.prototype.codePointAt` returns an integer representing the UTF-16 code unit at a specified index in a string. It is useful for dealing with Unicode characters. 

const str = '𠮷';
const codePoint = str.codePointAt(0);
console.log(codePoint); // 134071

`String.fromCharCode` returns a string created from the specified sequence of UTF-16 code units. It is used to convert code units to characters. 

const char = String.fromCharCode(65);
console.log(char); // 'A'

`String.prototype.startsWith` checks if a string starts with a specified substring and returns `true` if it does, otherwise `false`. 

const str = 'hello';
console.log(str.startsWith('he')); // true
console.log(str.startsWith('lo')); // false

`String.prototype.endsWith` checks if a string ends with a specified substring and returns `true` if it does, otherwise `false`. 

const str = 'hello';
console.log(str.endsWith('lo')); // true
console.log(str.endsWith('he')); // false

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