本什马克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);

结果呢?

0 Argument(s)
256
329
332
1 Argument(s)
307
418
4
2 Argument(s)
375
364
367
10 Argument(s)
962
601
604
40 Argument(s)
3095
1264
1260

享受吧!

你可以创建一个可重用的函数来使用任何参数，最简单的是这样的:

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

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

扩展语法可以在ES6及以上版本中使用…

但是如果你想使用与ES5及以下版本兼容的东西，你可以使用Array.prototype.slice。调用，所以你的代码看起来像这样:

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

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

还有一些其他方法可以做到这一点，例如使用array. from或循环参数并将它们分配给一个新数组…

Use:

function sortArguments() {
  return arguments.length === 1 ? [arguments[0]] :
                 Array.apply(null, arguments).sort();
}

阿雷(arg1, arg2， ..)

数组(str1)返回[str1]

Array(num1)返回一个包含num1个元素的数组

您必须检查参数的数量!

数组中。切片版(较慢):

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

数组中。推送版本(比切片慢，比切片快):

function sortArguments() {
  var args = [];
  Array.prototype.push.apply(args, arguments);
  return args.sort();
}

移动版本(较慢，但小尺寸更快):

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

数组中。Concat版本(最慢):

function sortArguments() {
  return Array.prototype.concat.apply([], arguments).sort();
}

使用array .from()，它接受一个类似数组的对象(比如参数)作为参数，并将其转换为数组:

(函数(){ console.log (Array.from(参数)); }(1,2,3));

注意，它在一些较老的浏览器(如IE 11)中不起作用，所以如果你想支持这些浏览器，你应该使用Babel。

另一个答案。

使用黑魔法咒语:

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

Firefox、Chrome、Node.js、IE11都可以。

ES6使用rest参数

如果你能使用ES6，你可以使用:

其他参数

函数sortArgs(…args) { 返回参数。排序(函数(a, b){返回a - b;})； ｝ document.body.innerHTML = sortArgs(12,4,6,8).toString();

你可以从链接中读到

rest形参语法允许我们将不确定数量的实参表示为数组。

如果你对…语法，它被称为扩散运算符，你可以在这里阅读更多。

ES6使用Array.from()

使用Array.from:

函数sortArgs() { return Array.from(arguments).sort(function (a, b) {return a - b;})； } document.body.innerHTML = sortArgs(12,4,6,8).toString();

from简单地将类数组或可迭代对象转换为数组实例。

ES5

你可以在arguments对象上使用Array的slice函数，它会把它转换成一个标准的JavaScript数组。你只需要通过Array的原型手动引用它:

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

为什么会这样?下面是ECMAScript 5文档本身的一段摘录:

注意:slice函数是有意通用的;它不要求它的this值是一个Array对象。因此，它可以转移到其他类型的对象中作为方法使用。slice函数能否成功应用于主机对象取决于实现。

因此，slice对任何具有length属性的东西都有效，而参数很方便地做到了这一点。

如果array .prototype.slice对你来说太拗口了，你可以使用数组字面量来略写它:

var args = [].slice.call(arguments);

然而，我倾向于认为前一个版本更明确，所以我更喜欢它。滥用数组文字符号会让人觉得很俗气，看起来很奇怪。