Question

我正在编写几个采用不同类型参数的函数。因此，这样做更简单：

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']]

但显然这不起作用。

Answer 1

如果您不想每次都写Array.prototype.slice.call(args)：

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

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

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

Answer 2

在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（为了向后兼容，请务必使用polyfill）：

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

如果您处于可以安全使用spread operator的环境中，则无需拨打slice：

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

Answer 3

您需要传递foo的参数对象并仅切片，就像这样

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

在arguments内使用parseArgs时，它会引用该函数收到的参数，而不是foo收到的参数。

在ECMA Script 2015中，您可以直接在arguments对象上使用Array.from，就像这样

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

或者，您可以保持parseArgs不变，并将arguments分散到parseArgs ECMA脚本2015中，就像这样

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

function foo() {
    console.log(parseArgs(...arguments));
}

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

Answer 4

怎么样：

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

var foo = function() {
    console.log(parseArgs(arguments))
}

foo('one', 'two', 'three')

这样就可以解析实际的参数array

Answer 5

有许多方法可以使arguments以导致函数不可优化的方式使用arguments。使用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);时必须非常小心。

来自MDN上的参数对象：

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

由于Node.js使用V8，你可能想做类似的事情：

@Override
public void onMapLongClick(LatLng latLng) {
    MarkerOptions markerOptions = new MarkerOptions().position(latLng);
    mMap.addMarker(markerOptions);
    markerOptions=getAddress(markerOptions);
    locations.add(latLng.latitude + ", " + latLng.longitude);
    databaseList.add(markerOptions);
}

处理Array.prototype.slice.call（参数）的更清洁的方法

5 个答案: