Javascript Functions MCQ

The <marquee> tag is used to create a scrolling text or image in HTML. It was first introduced in Internet Explorer and was later adopted by other web browsers. 
However, it is considered a non-standard element and its use is not recommended because it can create accessibility issues and is not supported by all web browsers. 
It is better to use alternative methods to create scrolling content, such as using CSS or JavaScript.

The <marquee> tag is a non-standard HTML element that is used to scroll a text or image either horizontally or vertically. 
In simple words, we can say that it automatically scrolls the image or text in up, down, left, and right direction.

valueOf() is a method that is available on many JavaScript objects, and it returns the primitive value of the object.
For example, if you have a number object x that was created using the Number constructor,
you can use the valueOf() method to get the primitive value of x.
Here's an example:
let x = new Number(5);
console.log(x.valueOf()); // Output: 5

The parseInt() function takes a string as input and returns an integer.
If the string cannot be converted to an integer, the function returns NaN.

The Math.random() function returns a random float between 0 and 1.
The Math.random() function returns a random float between 0 and 1 because this is the range of values that the function is designed to return.
The function uses a pseudo-random number generator to generate the random float, which means that the numbers it generates are not truly random, but they are good enough for most purposes.
The Math.random() function is often used to generate random numbers for things like games, simulations, and other applications where a truly random number is not required.

The setInterval() function executes a function repeatedly at a specified time interval (in milliseconds).
To stop the function from being executed, you can use the clearInterval() function.
This is useful when you want to perform a certain task at regular intervals, such as updating a value on a webpage or checking for new data from a server. The clearInterval() function is used to stop the function from being executed.
It takes the ID of the interval as an argument, which is returned by the setInterval() function when it is called.

The isNaN() function checks if a value is not a number (NaN).
It returns true if the value is NaN, and false if it is not.

The split() function splits a string into an array of substrings based on a specified delimiter.
The delimiter can be a character, a string, or a regular expression.

The sort() function sorts the elements of an array in ascending order.
By default, it compares the elements as strings.
You can pass a comparison function as an argument to sort the elements in a different way.

The substring() function extracts a part of a string and returns a new string.
It takes two arguments: the start index and the end index (optional).
The extracted part includes the characters from the start index to the end index (not including the character at the end index).

The encodeURIComponent() function encodes a string as a URI component.
It replaces certain characters (such as spaces and special characters) with their encoded version,
which can be safely used in a URI.

The isFinite() function checks if a value is a finite number.
It returns true if the value is a finite number, and false if it is not.

The join() function joins the elements of an array into a string.
It takes an optional separator as an argument, which is used to separate the elements in the resulting string.
If no separator is provided, the elements are joined with a comma.

A higher-order function is a function that either returns another function or takes another function as an argument, or both.
Higher-order functions are a powerful tool in functional programming because they allow you to create new functions by combining and modifying existing ones.

A callback function is a function that is passed as an argument to another function.
It is called (or "executed") when the event that it was passed to occurs.
Callback functions are often used to execute a certain task after an asynchronous operation has completed.

A closure is a function that has access to the outer function's variables even after the outer function has returned.
Closures are created when a function is defined inside another function and the inner function has access to the outer function's variables.
Closures are often used to create private variables and to preserve state in callback functions.

This function takes in a single argument, str, and uses the toLowerCase() method to convert the string to lowercase.
It then uses the split(), reverse(), and join() methods to check if the string is a palindrome (i.e., it reads the same forwards and backwards).

In this case, the greet function is a property of an object, and the this keyword refers to that object.

In this case, the greet function is an arrow function, which means that the this keyword is not dynamically bound to the object that the function is called on.
Instead, it refers to the value of this in the surrounding context, which in this case is the global object.

In this case, the add function is defined before it is called, so the function call is successful and returns the sum of the two numbers, 15.