arguments 对象

arguments 是一个类数组对象，可在 函数 内部访问，它包含传递给该函数的参数值。

试一试

描述

注意: 在现代代码中，应优先使用 rest 参数。

arguments 对象是所有非 箭头 函数中可用的局部变量。可以使用 arguments 对象在函数内部引用函数的参数。它包含函数被调用时传递的每个参数的条目，第一个条目的索引为 0。

例如，如果一个函数传递了 3 个参数，可以按如下方式访问它们

js
arguments[0]; // first argument
arguments[1]; // second argument
arguments[2]; // third argument

arguments 对象对于调用参数多于正式声明的参数的函数（称为 可变参数函数）非常有用，例如 Math.min()。此示例函数接受任意数量的字符串参数，并返回最长的一个

js
function longestString() {
  let longest = "";
  for (let i = 0; i < arguments.length; i++) {
    if (arguments[i].length > longest.length) {
      longest = arguments[i];
    }
  }
  return longest;
}

可以使用 arguments.length 计算函数被调用时传递了多少个参数。如果要计算函数声明要接受多少个参数，请检查该函数的 length 属性。

赋值给索引

每个参数索引也可以被设置或重新赋值

js
arguments[1] = "new value";

只有简单参数（即没有 rest、默认或解构参数）的非严格函数会将参数的新值与 arguments 对象同步，反之亦然

js
function func(a) {
  arguments[0] = 99; // updating arguments[0] also updates a
  console.log(a);
}
func(10); // 99

function func2(a) {
  a = 99; // updating a also updates arguments[0]
  console.log(arguments[0]);
}
func2(10); // 99

传递 rest、默认 或 解构 参数的非严格函数不会将分配给函数体中参数的新值与 arguments 对象同步。相反，具有复杂参数的非严格函数中的 arguments 对象将始终反映函数被调用时传递给函数的值。

js
function funcWithDefault(a = 55) {
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
funcWithDefault(10); // 10

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

// An untracked default parameter
function funcWithDefault3(a = 55) {
  console.log(arguments[0]);
  console.log(arguments.length);
}
funcWithDefault3(); // undefined; 0

这与所有 严格模式函数 的行为相同，无论它们传递的参数类型如何。也就是说，将新值分配给函数体中的参数永远不会影响 arguments 对象，反之亦然，即使函数只有简单参数，将新值分配给 arguments 索引也不会影响参数的值。

注意: 不能在接受 rest、默认或解构参数的函数定义主体中编写 "use strict"; 指令。这样做会导致 语法错误。

arguments 是一个类数组对象

arguments 是一个类数组对象，这意味着 arguments 具有 length 属性和从零开始索引的属性，但它没有 Array 的内置方法，例如 forEach() 或 map()。但是，可以使用 slice()、Array.from() 或 展开语法 将其转换为真正的 Array。

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

对于常见的用例，将其用作类数组对象就足够了，因为它既 可迭代 又具有 length 和数字索引。例如，Function.prototype.apply() 接受类数组对象。

js
function midpoint() {
  return (
    (Math.min.apply(null, arguments) + Math.max.apply(null, arguments)) / 2
  );
}

console.log(midpoint(3, 1, 4, 1, 5)); // 3

属性

arguments.callee

对 arguments 所属的当前执行函数的引用。在严格模式下禁止。

arguments.length

传递给函数的参数数量。

arguments[Symbol.iterator]()

返回一个新的 数组迭代器 对象，其中包含 arguments 中每个索引的值。

示例

定义一个连接多个字符串的函数

此示例定义一个连接多个字符串的函数。该函数的唯一形式参数是一个字符串，其中包含用于分隔要连接的项目的字符。

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

可以将任意数量的参数传递给此函数。它返回一个使用列表中的每个参数的字符串列表

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

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

myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
// "sage. basil. oregano. pepper. parsley"

定义一个创建 HTML 列表的函数

此示例定义一个创建包含 HTML 列表字符串的函数。该函数的唯一形式参数是一个字符串，如果列表为 无序（带项目符号），则为 "u"，如果列表为 有序（带编号），则为 "o"。函数定义如下

js
function list(type) {
  let html = `<${type}l><li>`;
  const args = Array.prototype.slice.call(arguments, 1);
  html += args.join("</li><li>");
  html += `</li></${type}l>`; // end list
  return html;
}

可以将任意数量的参数传递给此函数，它将每个参数作为列表项添加到指定类型的列表中。例如

js
list("u", "One", "Two", "Three");
// "<ul><li>One</li><li>Two</li><li>Three</li></ul>"

使用 typeof 与 arguments

当使用 arguments 时，typeof 运算符返回 'object'

js
console.log(typeof arguments); // 'object'

可以使用索引 arguments 来确定单个参数的类型

js
console.log(typeof arguments[0]); // returns the type of the first argument

规范

规范
ECMAScript 语言规范
# sec-arguments-exotic-objects

浏览器兼容性

BCD 表格仅在浏览器中加载

另请参阅