FE

Question 1

What is the JavaScript event loop, and how does it handle asynchronous code?

Answer 1

• The event loop manages JavaScript’s non-blocking execution.
• Executes synchronous code first (call stack).
• Asynchronous tasks go into:
  
  • Microtask Queue (Promises, MutationObserver) – runs before macrotasks.
  • Macrotask Queue (setTimeout, setInterval) – runs after microtasks.
• The event loop continuously checks if the call stack is empty before processing queued tasks.

Question 2

What is a closure in JavaScript, and why is it useful?

Answer 2

• A closure is a function that retains access to variables from its outer lexical scope, even after the outer function has executed.
• Useful for:
  
  • Encapsulation (private variables).
  • Maintaining state between function calls.
  • Avoiding global variables.

Example:

```js
function counter() {
let count = 0;
return function () {
count++;
console.log(count);
};
}
const increment = counter();
increment(); // 1
increment(); // 2
~~~

Here, count is remembered due to the closure.

Question 3

What is the prototype chain in JavaScript, and how does it enable inheritance?

Answer 3

• Every JavaScript object has a prototype (except Object.prototype).
• If an object doesn’t have a requested property, JavaScript checks its prototype, then its prototype’s prototype, until it reaches null.
• This allows inheritance, letting objects share methods without duplicating them.

Example:

```js
function Person(name) { this.name = name; }
Person.prototype.greet = function() { console.log(Hi, I'm ${this.name}); };

const alice = new Person(“Alice”);
alice.greet(); // Inherited from Person.prototype
~~~

• alice doesn’t have greet(), so JS looks up the prototype chain and finds it in Person.prototype.

Question 4

Why should shared methods be defined on the prototype instead of inside the constructor?

Answer 4

• If a method is defined inside the constructor, each instance gets its own copy, leading to unnecessary memory usage.
• If defined on the prototype, all instances share the same function, making memory usage more efficient.

Example:

```js
function Person(name) { this.name = name; }
Person.prototype.greet = function() { console.log(Hi, I'm ${this.name}); };

const alice = new Person(“Alice”);
const bob = new Person(“Bob”);

console.log(alice.greet === bob.greet); // true (shared method)
~~~

✅ Use the prototype for shared methods to save memory and improve performance.

Question 5

What will be the output?
```js
console.log(“Start”);

setTimeout(() => console.log(“Macrotask - setTimeout”), 0);

Promise.resolve().then(() => console.log(“Microtask - Promise”));

console.log(“End”);
~~~

Answer 5

Start  
End  
Microtask - Promise  
Macrotask - setTimeout  

Why?
- Microtasks run before macrotasks.

Question 6

What will be the output?
```js
function createCounter() {
let count = 0;
return function () {
count++;
console.log(count);
};
}

const counter1 = createCounter();
counter1();
counter1();

const counter2 = createCounter();
counter2();
~~~

Answer 6

1  
2  
1  

Why?
- Each createCounter() call creates a new closure with a separate count variable.

Question 7

What will be the output?
```js
function Person(name) {
this.name = name;
}

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

const alice = new Person(“Alice”);
const bob = new Person(“Bob”);

console.log(alice.greet === bob.greet);
~~~

Answer 7

true

Why?
- greet is defined on Person.prototype, so all instances share the same function reference.

Question 8

What will be the output?
```js
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 100);
}
~~~

Answer 8

3  
3  
3  

Why?
- var is function-scoped, so all iterations share the same i.
- By the time setTimeout() runs, i = 3.

Question 9

What will be the output?
```js
function Animal() {}
Animal.prototype.makeSound = function () {
console.log(“Some sound…”);
};

const dog = new Animal();
dog.makeSound = function () {
console.log(“Bark!”);
};

dog.makeSound();
delete dog.makeSound;
dog.makeSound();
~~~

Answer 9

Bark!  
Some sound...

Why?
- dog.makeSound is an instance property that overrides the prototype.
- After deletion, dog falls back to Animal.prototype.makeSound().

Question 10

What will be the output?
```js
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 100);
}
~~~

Answer 10

0  
1  
2  

Why?
- let is block-scoped, so each iteration gets its own i.