JavaScript Questions

Ritik Yadav

Score: 🔥 35

Intermediate

Took 20 minutes

Programming Language

JavaScript

80%

Questions Attempted

10 / 10

Correct Answers

Incorrect Answers

Points Earned

🔥 8

Question 1

Which of these methods allows you to explicitly set the this value when calling a function in JavaScript?

.forEach()
.map()
.call()
.filter()

Explanation:

The .call() method allows you to invoke a function with a specified this value and individual arguments provided separately. apply() is similar but takes an array of arguments.

Question 2

What will be logged to the console in this code snippet: console.log((function(a) { return a * a; })(5));?

5
10
25
undefined

Explanation:

This code demonstrates an immediately invoked function expression (IIFE). The function squares the input and is executed immediately with the argument 5, resulting in 25 being logged.

Question 3

What is a common practice to avoid deeply nested callbacks when working with multiple asynchronous operations?

Using nested 'try...catch' blocks extensively.
Chaining multiple '.then()' methods together.
Employing synchronous functions exclusively.
Switching to a different programming language.

Explanation:

Promise chaining provides a way to structure asynchronous code sequentially without nesting callbacks deeply. By chaining '.then()' methods, the result of one asynchronous operation is passed to the next, improving readability and maintainability.

Question 4

What is a common way to achieve encapsulation in JavaScript when modules are not an option (e.g., in older environments)?

Using global variables to store private data.
Leveraging closures to create private scopes and control access to variables and functions within those scopes.
Relying solely on comments to indicate private members, as there are no built-in mechanisms for true privacy.
Encapsulation is not achievable without modules in JavaScript.

Explanation:

Closures provide a way to emulate private members in JavaScript. Functions retain access to their lexical scope, even after the outer function has finished executing. This allows inner functions (within the closure) to act as getters and setters for variables defined in the outer function's scope, effectively hiding them from direct external access.

Question 5

What is the purpose of the .catch() method in Promise chaining?

To handle successful Promise resolutions.
To filter the results of a Promise.
To handle Promise rejections (errors).
To transform the resolved value of a Promise.

Explanation:

The .catch() method is crucial for handling errors in Promise chains. It executes when a Promise in the chain rejects, allowing you to gracefully handle the error.

Question 6

Which principle of object-oriented programming focuses on hiding internal implementation details and exposing only necessary information?

Inheritance
Polymorphism
Encapsulation
Abstraction

Explanation:

Encapsulation, a core OOP concept, involves bundling data (properties) and methods that operate on that data within an object, protecting the internal workings from external access.

Question 7

Which of the following methods is used to handle errors within an 'async/await' function?

.then()
.catch()
try...catch block
.finally()

Explanation:

While .catch() is used with Promises, the most appropriate way to handle errors specifically within an 'async/await' function is by using a standard 'try...catch' block. This allows for structured error handling within the asynchronous code.

Question 8

Which method is most efficient for finding a specific element in the DOM based on its ID?

querySelector('#my-id')
getElementsByClassName('my-class')[0]
getElementById('my-id')
querySelectorAll('#my-id')[0]

Explanation:

getElementById is the most efficient method for finding an element by its ID. The DOM specifically indexes elements by ID for this purpose, making it much faster than other methods.

Question 9

In JavaScript, how does the prototype chain relate to object inheritance?

The prototype chain determines the order of function execution within an object.
It establishes a hierarchy for property and method lookup, enabling objects to inherit from prototypes.
The prototype chain manages asynchronous tasks related to object creation.
It's used for event handling and propagation within the DOM.

Explanation:

When accessing an object's property or method, JavaScript traverses the prototype chain. If not found directly on the object, it checks the object's prototype, then its prototype, and so on, until found or reaching the end of the chain.

Question 10

What is the primary difference between 'nextSibling' and 'nextElementSibling' in DOM traversal?

'nextSibling' only works with elements, while 'nextElementSibling' works with any node type.
'nextSibling' might return a text node or comment, while 'nextElementSibling' only returns element nodes.
'nextSibling' traverses upwards in the DOM, while 'nextElementSibling' traverses downwards.
There is no difference; they are interchangeable.

Explanation:

The key difference is that 'nextElementSibling' skips over text nodes, comments, or other non-element nodes, while 'nextSibling' might return any type of node that is the next sibling.