In this guide, we’ll cover JavaScript functions step-by-step, from beginner to pro, with real-world usage, React integrations, and internal concepts.

🔹 Step 1: What is a Function?

A function is a reusable block of code designed to perform a particular task.

function greet(name) {
  return `Hello, ${name}`;
}

console.log(greet('Alice')); // Hello, Alice

📌 Why use functions?

• Reusability

• Better structure

• DRY (Don’t Repeat Yourself)

🔹 Step 2: Function Expressions & Arrow Functions

Function Expression:

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

Arrow Function:

const multiply = (a, b) => a * b;

✅ Arrow functions are cleaner and great for callbacks, but they do not bind their own this.

🔹 Step 3: Higher-Order Functions (HOFs)

A function that takes another function as an argument or returns one.

function withLogger(fn) {
  return function (...args) {
    console.log("Arguments:", args);
    return fn(...args);
  };
}

const add = (a, b) => a + b;
const loggedAdd = withLogger(add);

console.log(loggedAdd(2, 3)); // Logs args, returns 5

📌 Used in:

• Array.map(), Array.filter()

• Middleware in Redux

• Enhancing components in React

🔹 Step 4: Closures (The Secret Sauce 🔐)

Closures give access to an outer function’s scope even after the outer function has returned.

function counter() {
  let count = 0;
  return function () {
    count++;
    return count;
  };
}

const increment = counter();
console.log(increment()); // 1
console.log(increment()); // 2

✅ Used in React: for state updates like:

setCount(prev => prev + 1);

🔹 Step 5: Function Currying

Transforming a function with multiple arguments into a sequence of functions.

function multiply(a) {
  return function (b) {
    return a * b;
  };
}

const double = multiply(2);
console.log(double(5)); // 10

✅ Useful in functional programming, partial application, and React HOFs.

🔹 Step 6: call, apply, and bind

These control function context (this).

const user = {
  name: "Tom",
};

function greet(role) {
  return `${this.name} is a ${role}`;
}

console.log(greet.call(user, "Engineer")); // Tom is an Engineer

🔸 call – calls immediately with context
🔸 apply – like call but with an array of arguments
🔸 bind – returns a new function with this bound

🔹 Step 7: Composition in React

Functions as building blocks of components:

function Button({ children }) {
  return <button>{children}</button>;
}

function App() {
  return <Button>Click Me!</Button>;
}

✅ Composition lets you build flexible, reusable components instead of relying on inheritance.

🎯 Final Thoughts

Mastering functions means understanding:

• Basic declarations

• Scope and closures

• Function expressions vs. declarations

• call, apply, bind

• Currying

• Composition in React

Functions are everywhere—from handling events in the DOM to managing complex UI in React.

🧠 Practice Idea

Build a function utility library like:

• debounce

• throttle

• memoize

These are heavily used in real-world front-end performance tuning.

✍️ Written by Krishan — follow me on Twitter and GitHub and Linkedin

💡 Check out the current code examples and notes repo: GitHub

📝 Read more on my blog: Hashnode