I know it is used to make arguments
a real Array
, but I don‘t understand what happens when using Array.prototype.slice.call(arguments);
.
What happens under the hood is that when .slice()
is called normally, this
is an Array, and then it just iterates over that Array, and does its work.
How is this
in the .slice()
function an Array? Because when you do:
object.method();
...the object
automatically becomes the value of this
in the method()
. So with:
[1,2,3].slice()
...the [1,2,3]
Array is set as the value of this
in .slice()
.
But what if you could substitute something else as the this
value? As long as whatever you substitute has a numeric .length
property, and a bunch of properties that are numeric indices, it should work. This type of object is often called an array-like object.
The .call()
and .apply()
methods let you manually set the value of this
in a function. So if we set the value of this
in .slice()
to an array-like object, .slice()
will just assume it's working with an Array, and will do its thing.
Take this plain object as an example.
var my_object = { '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', length: 5 };
This is obviously not an Array, but if you can set it as the this
value of .slice()
, then it will just work, because it looks enough like an Array for .slice()
to work properly.
var sliced = Array.prototype.slice.call( my_object, 3 );
Example: http://jsfiddle.net/wSvkv/
As you can see in the console, the result is what we expect:
['three','four'];
So this is what happens when you set an arguments
object as the this
value of .slice()
. Because arguments
has a .length
property and a bunch of numeric indices, .slice()
just goes about its work as if it were working on a real Array.
The arguments
object is not actually an instance of an Array, and does not have any of the Array methods. So, arguments.slice(...)
will not work because the arguments object does not have the slice method.
Arrays do have this method, and because the arguments
object is very similar to an array, the two are compatible. This means that we can use array methods with the arguments object. And since array methods were built with arrays in mind, they will return arrays rather than other argument objects.
So why use Array.prototype
? The Array
is the object which we create new arrays from (new Array()
), and these new arrays are passed methods and properties, like slice. These methods are stored in the [Class].prototype
object. So, for efficiency sake, instead of accessing the slice method by (new Array()).slice.call()
or [].slice.call()
, we just get it straight from the prototype. This is so we don't have to initialise a new array.
But why do we have to do this in the first place? Well, as you said, it converts an arguments object into an Array instance. The reason why we use slice, however, is more of a "hack" than anything. The slice method will take a, you guessed it, slice of an array and return that slice as a new array. Passing no arguments to it (besides the arguments object as its context) causes the slice method to take a complete chunk of the passed "array" (in this case, the arguments object) and return it as a new array.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With