One of the aspects of mastering scope and the value of this
in JavaScript is to understand how apply
, call
and bind
work.
This article aims at simplifying these methods. I'll try to keep the explanation as simple as possible here.
this
in JS refers refers to the current context in which a function is being called. Although covering this
in detail is a separate article in itself, the main point to remember is that to determine the this
object, we need to see where the function is being invoked.
Amongst several possibilities of this
, we discuss three of the ways JS allows us to set what this
will be for a function.
To call a function in JS (and most other languages), we simply pass the parameters and invoke it. Example:
function logMe(text) {
console.log(text);
}
logMe('Canada')
// Output: 'Canada'
When apply
, call
and bind
come in the picture, it allows us to also specify the this
object for the function.
So, these methods allow us to invoke/call a JS function by specifying:
- the scope (
this
object) and - the params for the function we want to call.
☎️ apply
and call
Both of these methods are similar.
When being used, they both take the scope or the this
object as the first param followed by the parameters/arguments for the function.
The only difference is the way the arguments for the function are passed.
function invokeMe(val1, val2) {
// Note that the first `val` comes from the "this" object
// that the function is referring to
// and `val1` and `val2` are the function arguments.
console.log(`${this.val} ${val1} ${val2}`);
}
const thisObj = { val: 'JavaScript' };
const arg1 = 'Hello';
const arg2 = 'World';
invokeMe.apply(thisObj, [arg1, arg2]); // Output: 'JavaScript Hello World'
invokeMe.call(thisObj, arg1, arg2); // Output: 'JavaScript Hello World'
apply
takes the arguments to be passed in a single array.
call
takes the arguments to be passed explicitly.
A useful mnemonic I found here is
"a for array and c for comma."
🤝 bind
The method bind
also has the same calling syntax like call
but, the significant difference is that
call
calls the function immediately and,
bind
only binds the function and creates a new function that can be called later.
function invokeMe(val1, val2) {
console.log(`${this.val} ${val1} ${val2}`);
}
const thisObj = { val: 'JavaScript' };
const arg1 = 'Hello';
const arg2 = 'World';
// Binding the function ⬇
const bind1 = invokeMe.bind(thisObj, arg1, arg2); // No Output Yet
// Invoking the function ⬇
bind1(); // Output: 'JavaScript Hello World'
To better understand bind
, focus on the fact that it is for binding a function with a this
scope and not for immediate invocation.
This means that the arguments that need to be passed are not required when binding the function. They can be passed when invoking the function (usual programming style).
function invokeMe(val1, val2) {
console.log(`${this.val} ${val1} ${val2}`);
}
const thisObj = { val: 'JavaScript' };
const arg1 = 'Hello';
const arg2 = 'World';
// Binding the function ⬇
const bind2 = invokeMe.bind(thisObj); // No Output Yet
// Invoking the function ⬇
bind2(arg1, arg2); // Output: 'JavaScript Hello World'
That's it. That covers the key usage guidelines for apply
, call
and bind
. The explanation helps us understand that in OOPS, these methods help us reuse a single function for different objects without having to rewrite it for a new scope object.
Top comments (4)
Great, nice explained. Thanks for sharing.
Thanks bro, understood perfectly
Good example of Short and Sweet.
I love this mnemonic "a for array and c for comma." Thanks for sharing