Simple Explanation for call, apply, and bind in JavaScript

Let's break down call, apply and bind in a simple way

.call()

It allows you to invoke a function with a specified this value and individual arguments. Its syntax is as follows:

function.call(thisArg, arg1, arg2, ...)

Here, thisArg represents the value of this to be used when the function is called, while arg1, arg2, ... are the arguments passed to the function. For example:

function greet(name) {
  console.log(`Hello, ${name}! I am ${this.title}`);
}

const person = { title: "Mr." };
greet.call(person, "John");
// Output: Hello, John! I am Mr.

In this example, call ensures that the greet function is executed with person as the this value.

.apply()

Similar to call, the apply method is used to invoke a function with a specified this value. However, it differs in that it takes an array-like object as its second argument, representing the arguments to be passed to the function. The syntax is

function.apply(thisArg, [argsArray])

Here's an example:

function greet(name, age) {
  console.log(`Hello, ${name}! I am ${this.title} and I am ${age} years old.`);
}

const person = { title: "Mr." };
greet.apply(person, ["John", 25]);
// Output: Hello, John! I am Mr. and I am 25 years old.

.bind()

The bind method is used to create a new function that has a specified this value and pre-filled arguments. Its syntax is

function.bind(thisArg[, arg1[, arg2[, ...]]])

Here, thisArg is the value of this to be used, while arg1, arg2, ... are arguments to be partially applied. An example explains its usage:

function greet(name, age) {
  console.log(`Hello, ${name}! I am ${this.title} and I am ${age} years old.`);
}

const person = { title: "Mr." };
const greetPerson = greet.bind(person, "John");
greetPerson(25);
// Output: Hello, John! I am Mr. and I am 25 years old.

With bind, a new function greetPerson is created, ensuring that when it is invoked, it retains the specified this value and the pre-filled argument 'John'. This allows for more flexible function invocation in various contexts.

Learn Higher-Order Functions

Write code that is easier to understand and maintain.

You've heard about higher-order functions, but every explanation you've come across is either too technical or too vague. You're searching for something clear and practical, with examples that will help you practice and truly master the concept.

Higher-order functions are key to writing better code, essential for your projects, and expected in interviews. But getting started can be tough.

But what if you could? What if you had access to easy-to-understand content that not only explains higher-order functions but also provides hands-on practice? You’d finally feel confident using them in your projects, knowing exactly what they do and how to leverage them effectively.

It’s true, finding the right resources to learn higher-order functions can be challenging… but it doesn’t have to be.

Get my guide, where you’ll:

  • Understand why higher-order functions are worth learning and how they can transform your approach to writing JavaScript.
  • Gain clarity as I break down higher-order functions into simple, everyday language.
  • Master three important higher-order functions: map, filter, and reduce, with plenty of examples to solidify your understanding.
  • Apply your knowledge with real-world examples that demonstrate how these concepts work together, so you can use them easily in your projects or write better code in your interviews.

Get the Guide