JavaScript Functions

1. What is a Function?

A function is simply a reusable block of code designed to do one specific job. Instead of writing the same 10 lines of code every time you need to calculate a total price, you write it once inside a function and run it whenever you need it.

function greet(name) {
    return "Hello, " + name + "!";
}
console.log(greet("Alex")); // "Hello, Alex!"

const add = (a, b) => a + b;
const square = n => n * n;

console.log(add(5, 3));  // 8
console.log(square(4)); // 16

2. Default Values & Collecting Extra Inputs (`...rest`)

You can set fallback values in case someone forgets to pass an input, or collect any number of inputs into a list:

// 1. Default Parameters: Used if no value is passed in
function welcomeUser(name = "Guest", role = "Viewer") {
    return `Welcome ${name}! Your role is: ${role}`;
}

console.log(welcomeUser());               // "Welcome Guest! Your role is: Viewer"
console.log(welcomeUser("Anshuman", "Admin")); // "Welcome Anshuman! Your role is: Admin"

// 2. Rest Parameters (...numbers): Collects all remaining inputs into a list
function calculateTotal(...prices) {
    // prices is a normal array: [10, 20, 30]
    return prices.reduce((sum, p) => sum + p, 0);
}

console.log(calculateTotal(10, 20, 30, 40)); // 100

Welcome Guest! Your role is: Viewer
Welcome Anshuman! Your role is: Admin
100

3. Pure vs Impure Functions (Avoiding Side Effects)

A big secret to writing bug-free code is writing pure functions:

function calculateTax(price, taxRate) {
    return price + (price * taxRate);
}
// Predictable & easy to test!

let cartTotal = 0;
function addToCart(itemPrice) {
    cartTotal += itemPrice; // Changes external variable!
    return cartTotal;
}

4. Recursion: Functions That Call Themselves

A recursive function is simply a function that calls itself until it reaches a stopping point (called the base case).

// Example: Factorial (5! = 5 * 4 * 3 * 2 * 1)
function factorial(n) {
    // 1. Stopping point (Base Case)
    if (n <= 1) return 1;

    // 2. Call itself with a smaller number
    return n * factorial(n - 1);
}

console.log("5! is:", factorial(5)); // 120

5! is: 120

5. IIFE (Functions That Run Immediately)

An IIFE (Immediately Invoked Function Expression) is a function that runs automatically as soon as it is written. It is used to keep secret variables safe inside its own room:

const secretVault = (function() {
    // This variable is private and locked inside
    const secretCode = "SECRET_KEY_123";

    return {
        unlock(code) {
            return code === secretCode ? "Door Opened!" : "Access Denied!";
        }
    };
})();

console.log(secretVault.unlock("SECRET_KEY_123")); // "Door Opened!"
// console.log(secretCode); // ❌ Error! secretCode is protected inside

Door Opened!

6. Function Types at a Glance

7. Functions Interview Deck

Test your knowledge on function hoisting, arrow function characteristics, call-time default parameters, and pure functions:

sayHello();
sayBye();

function sayHello() {
    console.log("Hello");
}
var sayBye = function() {
    console.log("Bye");
};

const sum = (...args) => {
    return args.length;
};

console.log(sum(10, 20, 30, 40));

function addItem(item, list = []) {
    list.push(item);
    return list;
}

console.log(addItem("A"));
console.log(addItem("B"));

let tax = 0.05;

function getPrice(base) {
    return base + (base * tax);
}

function count(n) {
    if (n === 0) return "Done";
    return count(n - 1);
}

console.log(count(3));

8. Practice Challenge