Just Learn Code

Maximizing the Power of JavaScript’s call() Method: Chaining Constructors Borrowing Functions and More!

Introduction to the JavaScript call() method

Wouldnt it be great if we could use a single function with multiple objects? Thats possible with the JavaScript call() method.

The call() method can invoke functions with a specific object assigned to the this keyword, even if the function is not a method of that object. The method enables us to use the same function with different object instances and maintains a different this value, which we can specify as an argument.

In this article, we will explore the call() method by discussing its syntax, meaning of the thisArg and function arguments, referencing global and object properties, and the effect of setting the this value to the messenger object.

Syntax of the call() method

The call() method is a JavaScript built-in function that executes a function with a specified “this” value and arguments provided individually. The best way to understand the syntax is by breaking it down.

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

The syntax consists of two fundamental parts:

1. function – This is the function to execute.

2. Call() – This function invokes the function that we want to run.

The function executes with a specific object assigned to the this keyword, which is represented by thisArg. The call() method accepts function arguments as its arguments.

Any parameters passed after the thisArg are passed into the function as arguments. let object = {

propName: ‘I am an object property’,

printMessage: function () {




let message = {

propName: ‘I am a message property’,



In the above example, the call() method used object.printMessage.call(message) to print “I am a message property” using the Messenger object.

The call() method executes object.printMessage function in the Messenger context, not the object context. Meaning of thisArg, arg1, arg2, etc.

The first argument of the call() method is the thisArg, which is the object you want to reference. The thisArg specifies the value of the this keyword inside any function that is called by the call() method.

If thisArg is not specified, it defaults to the global object, which is the window object in web browsers or global in Node.js. The second argument and beyond form the function arguments that the method expects to receive.

Arguments passed to the call() method are passed to the function as individual arguments. When a function is called with call(), the arguments are not passed in an array or object.

Here is an example that demonstrates the meaning of thisArg, arg1, and arg2 using the call() method. function printBasketball(player1, player2, player3) {

console.log(`The best basketball players are ${player1}, ${player2} and ${player3}.

They play for the ${this.team} basketball team.`);


let basketballTeam = {

team: ‘Lakers’,


printBasketball.call(basketballTeam, ‘LeBron’, ‘AD’, ‘Dennis’);


The best basketball players are LeBron, AD, and Dennis. They play for the Lakers basketball team.

Using the JavaScript call() method to reference object properties

The call() method is used for more than just invoking a function within an object context. We can also use the call() method to access object properties, both global and object properties, using the same function.

Example of referencing global and object properties using call()

Sometimes functions need to access a global object or an object they may not be aware of. For example, lets create an object that contains a message.

let object = {

message: ‘Message from an object.’,



We can also use the call() method to access the object’s message property. function printMessage() {





Message from an object.

Effect of setting the this value to the messenger object

The this value can be set to a messenger object or any other object, and the function in question will use the properties of the messenger object instead of the this keyword. For example, consider a messenger object that sends messages.

let myMessenger = {

message: ‘I am a messenger!’,

deliverMessage: function (name) {

console.log(`${this.message} Hello ${name}!`);



The deliverMessage() function can be called with a name argument as follows. myMessenger.deliverMessage(‘Tom’);


I am a messenger! Hello Tom!

Alternatively, we can use the call() method to change the this value of the deliverMessage() function to the messenger object.

myMessenger.deliverMessage.call(myMessenger, ‘Tom’);


I am a messenger! Hello Tom!


The call() method is a powerful tool for invoking functions within different objects and contexts. We can use the call() method to specify the this value and function arguments when calling a function, regardless of its original context.

We can even reference global or object properties using the same function. The feature is an essential tool every JavaScript programmer should have in their arsenal.

Using the JavaScript call() method to chain constructors for an object

In JavaScript, inheritance is achieved through prototypes, making it unique from other object-oriented languages like Python and Java. Like other languages, JavaScript supports constructor functions, which we use to instantiate objects.

Constructor methods enable us to create new objects with pre-set properties and values. Sometimes we need to extend the functionality of the constructor to create more complex objects.

To do so, we can use the call() method to chain constructors.

Example of using call() for chaining constructors

In the following example, we will define two constructor functions, Box and Widget. A Box creates boxes with specified dimensions, while a Widget creates widgets with a given name.

Suppose we want to create an object that has both properties, its dimensions and a name. We can use call() to chain the Widget constructor to the Box constructor and combine their results.

Let’s start with the Box constructor function. function Box(width, height, depth) {

this.width = width;

this.height = height;

this.depth = depth;


Then we will define the Widget constructor.

function Widget(name) {

this.name = name;


Now we can define another constructor called BoxWidget. This constructor will create a box widget that has Name, Width, Height, and Depth properties.

function BoxWidget(width, height, depth, name) {

Box.call(this, width, height, depth);

Widget.call(this, name);


We use the Box constructor to set the Width, Height, and Depth dimensions. Then we use call() to call the Widget constructor function.

We pass in the BoxWidget object to change the context of this to the object created by BoxWidget.

Output of the example

Now we can create an instance of BoxWidget with the following code:

let newBoxWidget = new BoxWidget(5, 10, 15, ‘New Box Widget’);



BoxWidget { width: 5, height: 10, depth: 15, name: ‘New Box Widget’ }

Using the JavaScript call() method for function borrowing

The call() method also enables us to borrow methods from another object. This feature is useful for situations where we want to reuse existing functionality or methods.

When using call() to borrow a function, we pass the object we want to operate on as the this parameter. The borrowed function now has access to the properties of the object we passed as the this parameter.

Example of using call() for borrowing functions

Lets consider an example with a car and an aircraft object. The car object has a move() function that moves it to a specified distance.

The aircraft object also has a move() function, which moves it to a specific altitude. let car = {

move: function(distance) {

console.log(`The car moves ${distance} km.`);



let aircraft = {

move: function(altitude) {

console.log(`The aircraft flies at an altitude of ${altitude} km.`);



Now suppose we have an object that we want to move both in distance and altitude.

We can utilize the call() method to borrow the methods from car and aircraft. let object = {

altitude: 0,

distance: 0


function moveObject(distance, altitude) {

car.move.call(this, distance);

aircraft.move.call(this, altitude);


moveObject.call(object, 50, 1000);

In the above code, we define an object called object representing the object we want to move.

We create a moveObject function that borrows the move functions from car and aircraft, changing the this value to the object.

Explanation of how it works

The call() method borrows the move() function from car and aircraft, while modifying the this value to be the object representing the object we want to move. The moveObject() function can now reference the properties of the object as they have been passed through the this keyword.

Example of using arguments object with call() to borrow filter() method

Another practical example of using the call() method is when we want to borrow a method like filter() that requires arguments. Using call() with the arguments object allows us to borrow functions that we dont want to specify the parameters explicitly.

In the following example, we use the filter() method on an array called numbers. let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

let even = Array.prototype.filter.call(numbers, function(item) {

return item % 2 === 0;




[ 2, 4, 6, 8, 10 ]

The filter() method expects a function that tests for a condition, in this case, an even array.

We use the call() method to borrow function from numbers, while using the argument object to customize the function invocation.


In conclusion, the call() method is a powerful tool that enables us to execute functions in different contexts. We can use it to chain constructors and combine properties from different objects to create more complex objects.

We can also borrow methods and functions from other objects to take advantage of existing functionality. Using call() with the argument object allows us to specify parameters dynamically, without explicitly defining the parameter values.

To summarize, the JavaScript call() method is crucial for executing a function in different contexts or updating objects with new properties. We can use this method to chain constructors, combine properties from different objects, and borrow methods from other objects.

It also allows us to specify parameters dynamically without explicitly defining parameter values. JavaScript programmers should understand the usefulness of call() and utilize it for creating more robust, flexible, and efficient code.

As with anything in programming, practice is crucial. With more practice, programmers can master the call() method and leverage it to accomplish more complex tasks using JavaScript.

Popular Posts