A first-class functionin JavaScript means that functions are treated like any other value. This means
functions can:
1. Be assigned to variables.
2.
Be passed as arguments toother functions.
3.
Be returned from otherfunctions.
4.
Be stored in datastructures like arrays and objects.



Example: Assigning a function to a variable
const greet = function(name) {
return
Hello, ${name}!;
};
console.log(greet("Prakash")); // Output:Hello, Prakash!




Example: Passing a function as an argument
function executeFunction(fn, value) {
returnfn(value);
}

const square = (num) => num * num;

console.log(executeFunction(square, 5)); // Output:
25




Example: Returning a function from another function
function multiplyBy(factor) {
returnfunction(number) {

return number * factor;

};
}

const double = multiplyBy(2);
console.log(double(10)); // Output: 20


Since functions inJavaScript can be assigned, passed around, and returned just like any other
value, they are considered first-class citizens in JavaScript. 🚀

Q. What is the purpose of the let keyword

The let keyword in JavaScript is used to declare block-scoped variables, meaning the variable declared with let is only accessible within the block (or statement) in which it is defined. This contrasts with var, which is function-scoped, meaning it is accessible within the entire function in which it is declared, or globally if declared outside any function.

Key Characteristics of let:
1. Block Scope: Variables declared with let are limited to the block (or statement) in which they are defined. A block is typically defined by curly braces {} (like in if, for, or while blocks).
2. No Hoisting: While variables declared with var are hoisted (i.e., moved to the top of their scope), variables declared with let are not hoisted. They are in a "temporal dead zone" from the start of the block until the declaration is encountered, which means you can't access the variable before it's declared.
3. Re-declaration Not Allowed in the Same Scope: Unlike var, you cannot redeclare a variable within the same block or scope using let. This helps prevent accidental variable redeclarations.
4. Supports Re-assignment: You can reassign a value to a let variable after it has been initialized.

Example of let:
{
let a = 10;
console.log(a); // Outputs: 10
}

console.log(a); // Error: a is not defined because a is block-scoped
In the example above, a is only accessible within the block where it is defined. Outside the block, it’s undefined.

Example of let with re-assignment:
let x = 5;
x = 10; // Reassigning the value
console.log(x); // Outputs: 10
Example of Block Scope:
if (true) {
let name = 'John';
console.log(name); // Outputs: John
}

console.log(name); // Error: name is not defined because it's scoped to the block

Key Differences Between let and var:
• Scope:
o let has block scope, which means it is scoped to the nearest enclosing block (i.e., curly braces {}).
o var has function scope, which means it is scoped to the nearest function (or globally if declared outside any function).
• Re-declaration:
o A let variable cannot be redeclared in the same scope.
o A var variable can be redeclared within the same scope.
• Hoisting:
o Both var and let are hoisted, but while var is initialized with undefined, let variables are not initialized until the declaration is encountered in the code.

Summary:
The purpose of the let keyword is to declare variables with block scope, providing more predictable and manageable scoping compared to var. It helps prevent issues like variable hoisting and redeclaration in the same scope, making code easier to understand and debug.