Function.prototype: apply(), call(), bind()
Function.prototype.apply()
What does it need?
It takes it in context and optional arguments array.
How do we use it?
If I write func.apply(context, arguments), I like to think of the code actually executing as context.func(arguments), where each element of arguments would be translated by func as a regular list of arguments (like arg1, arg2, ..., argN instead of as an array).
Why do we want to use it?
- Set the context to something that doesn’t have that function built into it.
- Passing in an entire array of arguments to another function, like in a callback.
How do we remember it?
A for apply is A for array. apply() invokes the function now.
Function.prototype.call()
What does it need?
It takes in a context and, optionally, explicitly listed arguments (arg1, arg2, ..., argN). Note that this list of arguments is NOT an actual arguments array!
How do we use it?
If I write func.call(context, arg1, arg2, arg3), I imagine that the code is actually executed as context.func(arg1, arg2, arg3). This can be especially useful for copying only a select portion of the arguments array: Array.prototype.slice.call(arguments, 1)
I imagine this code executes as arguments.slice(1). This would not work had we used apply(). (Can you figure out why?)
Why do we want to use it?
- Like
apply(), to explicitly set the context to whatever we want it to be. - Again, like
apply(), to pass in arguments to another function (like a callback), except now we have to state each argument as a list.
How do we remember it?
C for call is… not… A for array… so, pass arguments in one-at-a-time!
Also, calling something is invoking something, so are indeed invoking the function now instead of saving a copy for later!
Function.prototype.bind()
What does it need?
It takes in a context and, optionally, a list of arguments (just like Function.prototype.call()).
How do we use it?
bind() is used to set the context of a function (just like apply() and call()) EXCEPT it doesn't execute the function. Rather, it returns a copy of the function bound to a new context. This means the version returned from bind() must be executed at a later moment.
Why do we want to use it?
Like apply() and call(), to explicitly set the context to whatever want it to be WITHOUT immediately executing the function. A great use case is for setTimeout(). Typically, the first argument we pass into setTimeout() is a function we want to execute later, so we may want to throw in a "bind-ed" version of a function.
How do we remember it?
B for bind is not A for array… so, pass arguments in one-at-a-time!bind() returns a copy of a function, so the original function is not invoked right now.
