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
複製代碼