5 Javascript coding interview questions - Part 5
Published: 2023-11-18 11:56:24

**Q1: Explain Prototypal Inheritance in JavaScript.**

**Ans:** Prototypal inheritance is a programming concept that allows objects to inherit properties and methods from other objects. In JavaScript, all objects are created with a prototype object, which is an object that contains the properties and methods that the object will inherit.
When you create a new object, you are essentially creating a copy of the prototype object. This means that the new object will have all of the same properties and methods as the prototype object. However, the new object also has its own set of properties and methods, which can be used to override or extend the properties and methods of the prototype object.

```
function Person(name) {
    this.name = name;
}
Person.prototype.greet = function() {
    return `Hello, my name is ${this.name}`;
};

function Student(name, grade) {
    this.name = name;
    this.grade = grade;
}
Student.prototype = Object.create(Person.prototype);

const student = new Student('Alice', 'A');
console.log(student.greet()); //Hello, my name is Alice
```

**Q2: Explain Asynchronous JavaScript and its use cases.**

**Ans:** Asynchronous JavaScript refers to the capability of executing code out of sequence, allowing other code to run while waiting for certain tasks to complete, such as network requests, file I/O, or timers. It's a fundamental feature in JavaScript, enabling non-blocking behavior and improving the responsiveness of web applications. Here are some key aspects and use cases of asynchronous JavaScript.

**--Key Aspects--**
**Non-blocking Execution:** Asynchronous operations don't halt the program's execution. Instead, they are initiated and allowed to complete independently while the main program continues to execute.

**Callbacks:** Often used to handle asynchronous operations, callbacks are functions passed as arguments to be executed once the operation is complete. However, nesting callbacks can lead to callback hell or difficult-to-read code.

**Promises:** Introduced to address the callback hell issue, promises provide a cleaner way to handle asynchronous code. They represent the eventual completion or failure of an asynchronous operation and enable chaining, error handling, and more readable code.

**Async/Await:** A more modern approach introduced in ES2017, async functions and the await keyword simplify working with asynchronous code, making it look more synchronous and easier to reason about.

**--Use Cases--**
**HTTP Requests:** Fetching data from APIs or servers is one of the most common use cases for asynchronous JavaScript. It prevents the user interface from freezing while waiting for the server's response.

**Timers and Intervals:** Setting timeouts or intervals for executing specific tasks asynchronously without blocking the main thread is another use case. For instance, updating the UI periodically or delaying certain actions.

**File Operations:** Reading and writing files asynchronously in web applications or Node.js environments, allowing other operations to proceed while waiting for file I/O to complete.

**Database Operations:** Asynchronous handling of database queries, especially in web servers, helps maintain responsiveness when dealing with databases.

**Event Handling:** Asynchronous code is commonly used in event-driven programming, where events can occur at unpredictable times. For example, handling user interactions in web applications.

**Concurrency:** Running multiple tasks concurrently without blocking each other, such as parallel processing or executing multiple asynchronous operations simultaneously.
  

```
console.log('Start');
setTimeout(() => {
    console.log('Delayed message');
}, 2000);
console.log('End');
// Outputs: Start, End, (after 2 seconds) Delayed message
```

**Q3: What is the purpose of the async and await keywords in JavaScript?.**

**Ans:** The async and await keywords in JavaScript are used to handle asynchronous code in a more synchronous and cleaner manner, making it easier to write and maintain asynchronous code. These keywords were introduced in ECMAScript 2017 (ES8) to simplify working with promises and asynchronous operations

**--Purpose--**
**1. Async Functions (async):** The async keyword is used to define an asynchronous function. It indicates that the function will always return a promise implicitly, even if the return value is not a promise.
Async functions enable you to write code that behaves asynchronously, but they look and feel like synchronous code, making asynchronous code more readable and easier to understand.

**2.Await Keyword:** The await keyword can only be used inside an async function. It is used to pause the execution of the async function until the promise is settled (resolved or rejected).
It waits for the promise to resolve and returns the resolved value or throws an error if the promise is rejected.
await can be applied to any promise-based function or operation that returns a promise (e.g., fetch, Promise.all, etc.).

Example:

```
async function fetchData() {
    try {
        let response = await fetch('https://api.example.com/data');
        let data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching data:', error);
        throw error;
    }
}
```

**Q4: What are Promises in JavaScript?.**

**Ans:** In JavaScript, a promise is an object that represents the eventual completion (or failure) of an asynchronous operation. Promises are a powerful tool for handling asynchronous operations, as they allow you to write code in a more synchronous-style.

```
function asyncOperation() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Operation completed successfully!');
            // or reject(new Error('Operation failed!'));
        }, 2000);
    });
}
asyncOperation()
    .then(result => console.log(result))
    .catch(error => console.error(error));

```

**Q5: what is Callbacks in javascript?.**

**Ans:** A callback is a function that is passed as an argument to another function and is intended to be executed after a specific task or event completes. Callbacks are a fundamental concept in asynchronous programming and are widely used in JavaScript to handle events, perform asynchronous operations, and more.

**--Benefits of Callbacks--**
**Asynchronous Operations:** Callbacks are extensively used to handle asynchronous tasks, such as making AJAX requests, reading files, or executing timers. They allow you to define what should happen after an asynchronous operation completes.

**Event Handling:** In event-driven programming, callbacks are used to respond to user actions or system events (e.g., click events, timers, HTTP requests). They allow you to define actions to be taken when an event occurs.

**Modularity and Reusability:** Callbacks promote modularity by allowing you to pass functions as arguments, making code more reusable. This enables the creation of higher-order functions that accept different callbacks to achieve different behaviors.

**Error Handling:** Callbacks can handle errors in asynchronous operations by using error-first callbacks (commonly used in Node.js). This convention enables handling both success and error cases within the same callback function. 
Example

```
readFile('file.txt', function(err, data) {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

```
**Control Flow:** Callbacks facilitate control flow mechanisms like serial or parallel execution of asynchronous tasks.We can pass a function as parameter in a function and called it from where we want.

```
function logString(){
  console.log("This is callback function")
}

function mainFun(callbackFun){

  console.log("Main function called.");
  callbackFun();
}

mainFun(logString);
```