What are the advantages of using arrow functions? 9

Vaibhav Kothia May 30, 2023 0 Comments

1. Arrow functions are more concise than regular functions, making code more readable. For example:

// Regular Function
const add = function(a, b) {
return a + b;
};

// Arrow Function
const add = (a, b) => a + b;

2. Arrow functions do not create their own this context, which means they can access the this value of the enclosing context. For example:

// Regular Function
const myObj = {
name: ‘John’,
sayName: function() {
console.log(this.name);
}
};

// Arrow Function
const myObj = {
name: ‘John’,
sayName: () => console.log(this.name)
};

3. Arrow functions are automatically bound to the parent context, which means they can be used as callbacks or in methods like map, filter, and reduce. For example:

// Regular Function
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(function(number) {
return number * 2;
});

// Arrow Function
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(number => number * 2);

4. Arrow functions do not have their own arguments object, so they can’t be used as constructors. For example:

// Regular Function
function Person(name) {
this.name = name;
}

// Arrow Function
const Person = name => {
this.name = name;
};

5. Arrow functions are always anonymous, which means they can’t be used as object methods. For example:

// Regular Function
const person = {
name: ‘John’,
sayName: function() {
console.log(this.name);
}
};

// Arrow Function
const person = {
name: ‘John’,
sayName: () => console.log(this.name)
};

6. Arrow functions do not have a prototype property, so they can’t be used as constructors. For example:

// Regular Function
function Person(name) {
this.name = name;
}

Person.prototype.sayName = function() {
console.log(this.name);
};

// Arrow Function
const Person = name => {
this.name = name;
};

Person.prototype.sayName = () => console.log(this.name);

7. Arrow functions cannot be used as generators. For example:

// Regular Function
function* generator() {
yield 1;
yield 2;
yield 3;
}

// Arrow Function
const generator = () => {
yield 1;
yield 2;
yield 3;
};

8. Arrow functions are always anonymous, which makes them difficult to debug. For example:

// Regular Function
const add = function(a, b) {
return a + b;
};

// Arrow Function
const add = (a, b) => a + b;

9. Arrow functions cannot be used as async functions. For example:

// Regular Function
async function getData() {
const response = await fetch(‘https://example.com/data’);
return response.json();
}

// Arrow Function
const getData = async () => {
const response = await fetch(‘https://example.com/data’);
return response.json();
};

What is a callback function?

Vaibhav Kothia May 30, 2023 0 Comments

A callback function is a function that is passed as an argument to another function and is executed after some kind of event. It is essentially a way to make sure certain code does not execute until other code has already finished execution.

For example, let’s say you have a function called “doSomething” that takes two arguments, a number and a callback. The callback is a function that will be called when the doSomething function is finished running:

function doSomething(num, callback) {
// do some work
let result = num * 2;
// call the callback when finished
callback(result);
}

// call doSomething, passing in a number and our callback
doSomething(2, function(result) {
console.log(result); // 4
});

What is the purpose of using closures in JavaScript?

Vaibhav Kothia May 26, 2023 0 Comments

Closures are used to create private variables and functions in JavaScript. A closure is a feature in JavaScript where an inner function has access to the outer (enclosing) function’s variables—a scope chain. The closure has three scope chains: it has access to its own scope (variables defined between its curly brackets), it has access to the outer function’s variables, and it has access to the global variables.

Example:

function outerFunction(x) {
let innerVariable = 3;

function innerFunction(y) {
return x + y + innerVariable;
}

return innerFunction;
}

let innerFunc = outerFunction(5);

console.log(innerFunc(2)); // 10