In JavaScript, functions are essentially methods because they are objects with the capability to execute code. The call() method allows one object to use the method of another object, making it versatile for method reuse across different contexts.

Basic Example of Using call()

If a function belongs to an object, it can be invoked on another object using the call() method. This is particularly useful when different objects share similar properties but do not inherit from a common prototype.

const person = {  firstName: "John",  lastName: "Doe",  fullName: function() {    return `${this.firstName} ${this.lastName}`;  }};‍const person1 = {  firstName: "Alice",  lastName: "Wonderland"};‍// Invoking person's fullName method on person1console.log(person.fullName.call(person1));  // Outputs "Alice Wonderland"

‍

Detailed Use of call()

The call() method allows you to specify the this value (i.e., the current object) explicitly, which refers to the object from which properties should be accessed. This method can be very powerful when you need to borrow a method from another object temporarily.

const person2 = {  firstName: "Mary",  lastName: "Doe"};‍// Using the same person's fullName method on a different objectconsole.log(person.fullName.call(person2));  // Outputs "Mary Doe"‍

Passing Arguments with call()

In addition to setting the this value, call() can also pass arguments to the function it is invoking. This feature extends its utility, allowing the borrowed method to behave as if it were a method of the object itself, with additional contextual data.

const person = {  fullName: function(city, country) {    return `${this.firstName} ${this.lastName} from ${city}, ${country}`;  }};// Passing additional arguments to the methodconsole.log(person.fullName.call(person1, "Oslo", "Norway"));  // Outputs "Alice Wonderland from Oslo, Norway"

Summary

The call() method in JavaScript is a powerful feature for function invocation that allows you to control the this context explicitly and pass arguments. It is ideal for applying a function across various objects without needing to bind them permanently, thus maintaining clean and flexible code architecture. This method is particularly useful in scenarios where objects share similar data structures but do not come from the same prototype chain.

‍

Take a look into your desired course