Arguments 对象

arguments 是一个对应于传递给函数的参数的类数组对象。

arguments对象是全部（非箭头）函数中均可用的局部变量。你可使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每一个参数，第一个参数在索引0处。例如，若是一个函数传递了三个参数，你能够以以下方式引用他们：

arguments[0]
arguments[1]
arguments[2]
复制代码

参数也能够被设置：

arguments[1] = 'new value';
复制代码

arguments对象不是一个 Array。它相似于Array，但除了length属性和索引元素以外没有任何Array属性。例如，它没有 pop 方法。可是它能够被转换为一个真正的Array：

var args = Array.prototype.slice.call(arguments); var args = [].slice.call(arguments); // ES2015 const args = Array.from(arguments);

对参数使用slice会阻止某些JavaScript引擎中的优化 (好比 V8 - 更多信息)。若是你关心性能，尝试经过遍历arguments对象来构造一个新的数组。另外一种方法是使用被忽视的Array构造函数做为一个函数：

var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));

若是调用的参数多于正式声明接受的参数，则可使用arguments对象。这种技术对于能够传递可变数量的参数的函数颇有用。使用 arguments.length来肯定传递给函数参数的个数，而后使用arguments对象来处理每一个参数。要肯定函数签名中（输入）参数的数量，请使用Function.length属性。

对参数使用 typeof节 typeof参数返回 'object'。

`console.log(typeof arguments);    // 'object'
// arguments 对象只能在函数内使用
function test(a){
    console.log(a,Object.prototype.toString.call(arguments));
    console.log(arguments[0],arguments[1]);
    console.log(typeof arguments[0]);
}
test(1);
/*
1 "[object Arguments]"
1 undefined
number
*/`
复制代码

可使用索引肯定单个参数的类型。

console.log(typeof arguments[0]); //this will return the typeof individual arguments.

复制代码

对参数使用扩展语法节 您还可使用Array.from()方法或扩展运算符将参数转换为真实数组：

var args = Array.from(arguments);
var args = [...arguments];
复制代码

arguments.callee
复制代码

指向当前执行的函数。

arguments.caller 
复制代码

指向调用当前函数的函数。

arguments.length
复制代码

指向传递给当前函数的参数数量。

arguments[@@iterator]
复制代码

返回一个新的Array迭代器对象，该对象包含参数中每一个索引的值。 注意:如今在严格模式下，arguments对象已与过往不一样。arguments[@@iterator]再也不与函数的实际形参之间共享，同时caller属性也被移除。 例子节 遍历参数求和节

function add() {
    var sum =0,
        len = arguments.length;
    for(var i=0; i<len; i++){
        sum += arguments[i];
    }
    return sum;
}
add()                           // 0
add(1)                          // 1
add(1,2,3,4);                   // 10
复制代码

定义链接字符串的函数节 这个例子定义了一个函数来链接字符串。这个函数惟一正式声明了的参数是一个字符串，该参数指定一个字符做为衔接点来链接字符串。该函数定义以下：

function myConcat(separator) { var args = Array.prototype.slice.call(arguments, 1); return args.join(separator); }

你能够传递任意数量的参数到该函数，并使用每一个参数做为列表中的项建立列表。

// returns "red, orange, blue"
myConcat(", ", "red", "orange", "blue");

// returns "elephant; giraffe; lion; cheetah"
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// returns "sage. basil. oregano. pepper. parsley"
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
复制代码

定义建立HTML列表的方法节 这个例子定义了一个函数经过一个字符串来建立HTML列表。这个函数惟一正式声明了的参数是一个字符。当该参数为 "u" 时，建立一个无序列表 (项目列表)；当该参数为 "o" 时，则建立一个有序列表 (编号列表)。该函数定义以下：

function list(type) {
  var result = "<" + type + "l><li>";
  var args = Array.prototype.slice.call(arguments, 1);
  result += args.join("</li><li>");
  result += "</li></" + type + "l>"; // end list

  return result;
}
复制代码

你能够传递任意数量的参数到该函数，并将每一个参数做为一个项添加到指定类型的列表中。例如：

var listHTML = list("u", "One", "Two", "Three");

/* listHTML is:

"

• One
• Two
• Three

"

*/ 剩余参数、默认参数和解构赋值参数节 arguments对象能够与剩余参数、默认参数和解构赋值参数结合使用。

function foo(...args) {
  return args;
}
foo(1, 2, 3);  // [1,2,3]
复制代码

在严格模式下，剩余参数、默认参数和解构赋值参数的存在不会改变 arguments对象的行为，可是在非严格模式下就有所不一样了。

当非严格模式中的函数没有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值会跟踪参数的值（反之亦然）。看下面的代码：

function func(a) { 
  arguments[0] = 99;   // 更新了arguments[0] 一样更新了a
  console.log(a);
}
func(10); // 99
复制代码

而且

function func(a) { 
  a = 99;              // 更新了a 一样更新了arguments[0] 
  console.log(arguments[0]);
}
func(10); // 99
复制代码

当非严格模式中的函数有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值不会跟踪参数的值（反之亦然）。相反, arguments反映了调用时提供的参数：

function func(a = 55) { 
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
func(10); // 10
复制代码

而且

function func(a = 55) { 
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
func(10); // 10
复制代码

而且

function func(a = 55) { 
  console.log(arguments[0]);
}
func(); // undefined
复制代码