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.

由于<代码>arguments的物体与阵列非常相似,因此两种物体是相容的。 这意味着,我们可以使用有争论的阵列方法。 由于阵列方法是用阵列构造的,它们将返回阵列而不是其他论点。

因此,为什么使用<代码>Array.prototype?Array是我们从(new Array(<><>new Array(><>>>>>>>>>)中创建新阵列的物体,这些新阵列如斜体。 这些方法储存在<代码>[Class]。 因此,为了提高效率,我们不要通过<代码>(新轨道)或<代码>(<>/代码>或<代码>查询(>>)而从原型中取而代之。 因此,我们不必开始一个新的阵列。

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.

通常,打电话

var b = a.slice();

<代码>a将复制到<条码>。 然而,我们不能这样做。

var a = arguments.slice();

因为arguments n't have slice as a means (it's not a real range).

<代码>Array.prototype.slice =阵列的功能>。slice , with the this Value set to arguments。

Array.prototype.slice. calls(arguments)是将论点转化为阵列的老方法。

In ECMAScript 2015, you can use Array.from or the spread operator:

let args = Array.from(arguments);

let args = [...arguments];

首先,请见, 豪华文/a>上的援引工程。 我怀疑,光是回答你的问题就够了。 但这里概述了正在发生的情况:

<代码>Array.prototype.slice 摘录:slicemethods,因为它采用了一种方法(而不是一种功能),因此需要一种环境(一个叫物体,this),否则它就会扔进。 攻击类型 Error: Array.prototype.slice calls on abolition or un Defin.

The call() method allows you to specify a method s context, basically making these two calls equivalent:

someObject.slice(1, 2);
slice.call(someObject, 1, 2);

除前一种要求外,<代码>slice方法将存在于<编码>。 目标原型链(如Array>),而后一链条允许将背景(someObject)手工通过。

Also, the latter is short for:

var slice = Array.prototype.slice;
slice.call(someObject, 1, 2);

这与:

Array.prototype.slice.call(someObject, 1, 2);

// We can apply `slice` from  `Array.prototype`:
Array.prototype.slice.call([]); //-> []

// Since `slice` is available on an array s prototype chain,
 slice  in []; //-> true
[].slice === Array.prototype.slice; //-> true

// … we can just invoke it directly:
[].slice(); //-> []

// `arguments` has no `slice` method
 slice  in arguments; //-> false

// … but we can apply it the same way:
Array.prototype.slice.call(arguments); //-> […]

// In fact, though `slice` belongs to `Array.prototype`,
// it can operate on any array-like object:
Array.prototype.slice.call({0: 1, length: 1}); //-> [1]

其原因是,作为

The arguments object is not an array. It is similar to an array, but does not have any array properties except length. For example, it does not have the pop method. However it can be converted to a real array:

var args = Array.prototype.slice.call(arguments);