我如何将“转换为”；“论点”；对象到JavaScript中的数组？

JavaScript中的

arguments

对象是一个奇怪的缺点，在大多数情况下，它的行为就像一个数组，但实际上它不是一个数组对象。因为它是一个函数，所以它没有像

forEach

、

sort

、

filter

和

map

这样的有用函数

从带有简单for循环的arguments对象构造新数组非常容易。例如，此函数对其参数进行排序：

function sortArgs() {
    var args = [];
    for (var i = 0; i < arguments.length; i++)
        args[i] = arguments[i];
    return args.sort();
}

函数sortArgs（）{
var args=[]；
for（var i=0；i

然而，仅仅为了访问极其有用的JavaScript数组函数，就必须这样做，这是一件相当可怜的事情。是否有使用标准库的内置方法？

ES6使用rest参数 如果您能够使用ES6，您可以使用：

函数sortArgs（…args）{
返回args.sort（函数（a，b）{returna-b；}）；
}
document.body.innerHTML=sortArgs（12,4,6,8）.toString（）如果您使用的是jQuery，我认为以下内容更容易记住：

function sortArgs(){
  return $.makeArray(arguments).sort();
}

有些数组方法故意不要求目标对象是实际数组。它们只要求目标具有名为length的属性和索引（必须是零或更大的整数）

这是一个非常古老的问题，但我认为我有一个比以前的解决方案更容易键入的解决方案，并且不依赖于外部库：

function sortArguments() {
  return Array.apply(null, arguments).sort();
}

将参数转换为数组的几种方法之一

对我来说，解决少量争论的最佳方案是：

function sortArgs (){
  var q = [];
  for (var k = 0, l = arguments.length; k < l; k++){
    q[k] = arguments[k];
  }
  return q.sort();
}

使用：

数组（arg1，arg2，…）
返回
[arg1，arg2，…]

数组（str1）
返回
[str1]

Array（num1）
返回包含
num1
元素的数组

您必须检查参数的数量

Array.slice
版本（较慢）：

Array.push
version（比slice慢、快）：

移动版本（速度较慢，但小尺寸更快）：

还值得一提的是，它展示了如何管理数组中的
参数
对象，使函数在V8 JavaScript引擎下可优化：

function doesntLeakArguments() {
    var args = new Array(arguments.length);
    for(var i = 0; i < args.length; ++i) {
        args[i] = arguments[i];
    }
    return args;
}

函数doesntLeakArguments（）{
var args=新数组（arguments.length）；
对于（变量i=0；i

此方法用于支持
var args=[].slice.call（参数）。作者还展示了构建步骤如何帮助减少冗长。
另一个答案

使用黑魔法咒语：

function sortArguments() {
  arguments.__proto__ = Array.prototype;
  return arguments.slice().sort();
}

Firefox、Chrome、Node.js、IE11都还可以。
Benshmarck 3方法：

function test()
{
  console.log(arguments.length + ' Argument(s)');

  var i = 0;
  var loop = 1000000;
  var t = Date.now();
  while(i < loop)
  {
      Array.prototype.slice.call(arguments, 0); 
      i++;
  }
  console.log(Date.now() - t);


  i = 0,
  t = Date.now();
  while(i < loop)
  {
      Array.apply(null, arguments);
      i++;
  }
  console.log(Date.now() - t);

  i = 0,
  t = Date.now();
  while(i < loop)
  {
      arguments.length == 1 ? [arguments[0]] : Array.apply(null, arguments);
      i++;
  }
  console.log(Date.now() - t);
}

test();
test(42);
test(42, 44);
test(42, 44, 88, 64, 10, 64, 700, 15615156, 4654, 9);
test(42, 'truc', 44, '47', 454, 88, 64, '@ehuehe', 10, 64, 700, 15615156, 4654, 9,97,4,94,56,8,456,156,1,456,867,5,152489,74,5,48479,89,897,894,894,8989,489,489,4,489,488989,498498);

享受吧
 在ECMAScript 6中，没有必要使用像
Array.prototype.slice（）
这样难看的黑客。您可以使用


（函数（）{
log（[…参数]）；
}（1，2，3））
我建议使用ECMAScript 6，它将尾部参数绑定到数组。使用此解决方案，您无需触摸
参数
对象，代码将得到简化。这个解决方案的缺点是它不能在大多数浏览器中工作，因此您必须使用JS编译器，比如Babel。在后台，巴贝尔将
参数
转换为一个带有for循环的数组

function sortArgs(...args) {
  return args.sort();
}

如果您不能使用ECMAScript 6，我建议您查看其他一些答案，例如@Jonathan Fingland

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

使用，它将类似数组的对象（例如
参数
）作为参数，并将其转换为数组：


（函数（）{
log（Array.from（arguments））；
}(1, 2, 3));
函数sortArgs（…args）{
返回args.sort（函数（a，b）{returna-b；}）；
}
document.body.innerHTML=sortArgs（1,2,3,4）.toString（）尝试使用

说明：将
参数的
prototype
设置为
数组。prototype


函数toArray（）{
return Object.setPrototypeOf（参数，数组.prototype）
} 
log（toArray（“abc”，123，{def:456}，[0，[7，[14]]]）
尽管rest参数工作正常，但如果出于某种原因想继续使用
参数，请考虑

function sortArgs() {
  return [...arguments].sort()
}

[…arguments]
可以看作是
数组的一种替代品。from（arguments）
也可以很好地工作

ES7替代方案是阵列理解：

[for (i of arguments) i].sort()

如果要在排序之前处理或筛选参数，这可能是最简单的：

[for (i of arguments) if (i % 2) Math.log(i)].sort()

我尝试了简单的破坏技术

function sortArg(){
var args = Array.from(arguments); return args.sort();
}


函数sortArg（）{
var args=Array.from（参数）；
返回args.sort（）；
}
控制台日志（sortArg（'a'，'b'，1,2'，'34'，88,20'，'19'，39'，'d'，'z'，'ak'，'bu'，90））洛达斯：

var args = _.toArray(arguments);

在行动中：

(function(){ console.log(_.toArray(arguments).splice(1)); })(1, 2, 3)

产生：

[2,3]

Arguments对象仅在函数体中可用。虽然可以像数组一样索引Arguments对象，但它不是数组。除了长度之外，它没有任何数组属性


//函数参数长度5
函数属性（a、b、c、d、e）{
var function_name=arguments.callee.name
var arguments_length=arguments.length；
var properties_length=properties.length；
var函数_from=properties.caller.name；
log（'I是函数名：'+函数名）；
log（'我是函数长度，我是函数空间：'+属性\长度）；
log（'我是参数长度，我是上下文/执行空间：'+参数长度）；
log（'正在从调用我：'+函数\u From）；
}
//论据3
函数父函数（）{
性质（1,2,3）；
}
//参数长度为3，因为执行空间指定
父项（）您可以创建一个可重复使用的函数来处理任何参数，最简单的一个是这样的：

function sortArgs() {
  return [...arguments].sort();
}

sortArgs('ali', 'reza', 1, 2, 'a'); //[1, 2, "a", "ali", "reza"];

扩展语法可以扩展到b
function sortArgs() {
    var args = Array.prototype.slice.call(arguments);
    return args.sort();
}

function sortArgs() {
  return [...arguments].sort()
}

[for (i of arguments) i].sort()

[for (i of arguments) if (i % 2) Math.log(i)].sort()

 function x(){
   var rest = [...arguments]; console.log(rest);return     
   rest.constructor;
 };
 x(1,2,3)

function sortArg(){
var args = Array.from(arguments); return args.sort();
}

var args = _.toArray(arguments);

(function(){ console.log(_.toArray(arguments).splice(1)); })(1, 2, 3)

[2,3]

function sortArgs() {
  return [...arguments].sort();
}

sortArgs('ali', 'reza', 1, 2, 'a'); //[1, 2, "a", "ali", "reza"];

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

sortArgs('ali', 'reza', 1, 2, 'a'); //[1, 2, "a", "ali", "reza"];