处理 Array.prototype.slice.call(参数）的更简洁方法

Cleaner way of handling Array.prototype.slice.call(arguments)

本文关键字：简洁 方法 参数 Array prototype slice call 处理      更新时间：2023-09-26

我正在编写几个采用不同类型参数的函数。因此，只做以下操作要简单得多：

var myFunc = function() {
    var args = Array.prototype.slice.call(arguments)
}

。而不是尝试直接在函数声明的参数字段中处理所有不同的可能性，例如：

var myFunc = function(param1, param2, param3) {
    if (param3) {
        // etc.
    }
}

不过，Array.prototype.slice.call(arguments)增加了很多代码，并降低了可读性。我试图弄清楚是否有一种方法可以编写一个可以完成与Array.prototype.slice.call()相同的辅助函数，但更干净，更易于阅读。我正在尝试类似的东西：

var parseArgs = function() {
    return Array.prototype.slice.call(arguments)
}
var foo = function() {
    console.log(parseArgs(arguments))
}
foo('one', 'two', 'three')
// [Arguments, ['one', 'two', 'three']]

但显然这是行不通的。

如果你不想每次都写Array.prototype.slice.call(args)你可以做：

var slice = Function.call.bind(Array.prototype.slice);

然后你可以在任何地方使用它，比如：

function fn(){
    var arr = slice(arguments);
}

在 JS 中将类似数组的对象转换为实际数组的一些简写：

别名Array.prototype.slice：

(function (slice) {
  ...your code...
  function someFunction() {
    var args = slice.call(arguments);
    ...
  }
  ...
}(Array.prototype.slice));

使用[].slice ：

function someFunction() {
  var args = [].slice.call(arguments);
}

创建自己的切片（您尝试过此操作，但参数中出现错误）：

function slice(arr) {
  return Array.prototype.slice.call(arr);
}
function someFunction() {
  var args = slice(arguments);
}

使用新式Array.from（确保填充以实现向后兼容性）：

function someFunction() {
  var args = Array.from(arguments);
}

如果您处于可以安全使用 spread 运算符的环境中，则无需调用任何 slice ：

function someFunction() {
  var args = [...arguments];
}

你需要传递 foo 的参数对象并仅对其进行切片，如下所示

function parseArgs(args) {
    return Array.prototype.slice.call(args);
}

当您在parseArgs中使用arguments时，它将仅引用该函数收到的参数，而不是foo收到的参数。

在 ECMA 脚本 2015 中，可以直接arguments对象上使用Array.from，如下所示

function foo() {
    console.log(Array.from(arguments));
}

或者，您可以保持parseArgs原样，并将arguments分布在 ECMA 脚本 2015 中的parseArgs上，如下所示

function parseArgs() {
    return Array.prototype.slice.call(arguments);
}
function foo() {
    console.log(parseArgs(...arguments));
}

这基本上意味着您正在传播foo收到的arguments并将它们传递给parseArgs，以便它也会收到相同的参数。

怎么样：

var parseArgs = function(args) {
    return Array.prototype.slice.call(args)
}
var foo = function() {
    console.log(parseArgs(arguments))
}
foo('one', 'two', 'three')

这样，您可以解析实际参数array

有许多方法可以使用arguments，从而导致

函数不可优化。使用时必须非常小心 arguments .

从 MDN 上的参数对象：

重要提示：您不应该对参数进行切片，因为它会阻止 JavaScript 引擎（例如 V8）中的优化。相反，请尝试通过循环访问参数对象来构造一个新数组。

由于 Node.js 使用 V8，您可能希望执行以下操作：

function parseArgs() {
  var args = new Array(arguments.length);
  for (var i = 0; i < arguments.length; ++i) {
    args[i] = arguments[i];
  }
  return args;
}
function myFunc() {
  var args = parseArgs.apply(null, arguments);
  console.log(args); // => [1,2,3]
}
myFunc(1, 2, 3);

相关文章：