it-swarm.com.de

Wie kann ich das Objekt "arguments" in JavaScript in ein Array konvertieren?

Das Objekt arguments in JavaScript ist eine seltsame Warze - es verhält sich in den meisten Situationen genau wie ein Array, ist jedoch kein tatsächlich Array-Objekt. Da es wirklich etwas ganz anderes ist, hat es nicht die nützlichen Funktionen von Array.prototype wie forEach, sort, filter und map.

Es ist ganz einfach, ein neues Array aus einem Argumentobjekt mit einer einfachen for-Schleife zu erstellen. Zum Beispiel sortiert diese Funktion ihre Argumente:

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

Dies ist jedoch eine erbärmliche Sache, die Sie tun müssen, um Zugriff auf die äußerst nützlichen JavaScript-Array-Funktionen zu erhalten. Gibt es eine integrierte Möglichkeit, dies mithilfe der Standardbibliothek zu tun?

414
Andrew Coleson

ES6 mit Restparametern

Wenn Sie ES6 verwenden können, können Sie Folgendes verwenden:

Restparameter

function sortArgs(...args) {
  return args.sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(12, 4, 6, 8).toString();

Wie Sie in link lesen können

Mit der Rest-Parametersyntax können wir eine unbegrenzte Anzahl von Argumenten als Array darstellen.

Wenn Sie sich für die ...-Syntax interessieren, heißt sie Spread Operator und Sie können mehr hier lesen.

ES6 mit Array.from ()

Verwenden von Array.from:

function sortArgs() {
  return Array.from(arguments).sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(12, 4, 6, 8).toString();

Array.from konvertiert einfach Array-ähnliche oder Iterable-Objekte in Array-Instanzen. 



ES5

Sie können tatsächlich die Array-Funktion s slice für ein Argumentobjekt verwenden und diese in ein Standard-JavaScript-Array konvertieren. Sie müssen lediglich manuell anhand des Prototyps von Array darauf verweisen:

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

Warum funktioniert das? Hier ist ein Auszug aus der ECMAScript 5-Dokumentation selbst :

NOTE: Die Funktion slice ist absichtlich generisch. Es ist nicht erforderlich, dass der this -Wert ein Array-Objekt ist. Daher kann es auf andere Arten von Objekten zur Verwendung als Methode übertragen werden. Ob die slice-Funktion erfolgreich auf ein Host-Objekt angewendet werden kann, hängt von der Implementierung ab.

Daher funktioniert slice für alles, was eine length -Eigenschaft hat, was arguments praktischerweise tut.


Wenn Array.prototype.slice zu viel für Sie ist, können Sie ihn leicht mit Array-Literalen abkürzen:

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

Ich neige jedoch dazu, dass die frühere Version expliziter ist, also würde ich sie lieber bevorzugen. Wenn Sie die wörtliche Notation des Arrays missbrauchen, fühlt es sich hart an und sieht seltsam aus.

671

Es empfiehlt sich auch, auf dieses Bluebird verspricht Bibliotheks-Wiki-Seite zu verweisen, das zeigt, wie das arguments-Objekt in einem Array so verwaltet wird, dass die Funktion unter der V8 JavaScript-Engine

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

Diese Methode wird zugunsten von var args = [].slice.call(arguments); verwendet. Der Autor zeigt auch, wie ein Build-Schritt dazu beitragen kann, die Ausführlichkeit zu reduzieren.

38
jbmusso
function sortArgs(){ return [].slice.call(arguments).sort() }

// Returns the arguments object itself
function sortArgs(){ return [].sort.call(arguments) }

Einige Array-Methoden werden absichtlich so erstellt, dass das Zielobjekt kein tatsächliches Array ist. Sie erfordern lediglich, dass das Ziel eine Eigenschaft namens length und Indizes hat (die ganze oder gleich null sein müssen).

[].sort.call({0:1, 1:0, length:2}) // => ({0:0, 1:1, length:2})
28
matyr

Benutzen:

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

Array(arg1, arg2, ...) gibt [arg1, arg2, ...] zurück

Array(str1) gibt [str1] zurück

Array(num1) gibt ein Array mit num1-Elementen zurück

Sie müssen die Anzahl der Argumente prüfen!

Array.slice version (langsamer):

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

Array.Push version (langsamer, schneller als slice):

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

Version verschieben (langsamer, aber kleiner ist schneller):

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

Array.concat version (langsamste):

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

Wenn Sie jQuery verwenden, ist das Folgende meiner Meinung nach viel einfacher zu merken:

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

Hier ist Benchmark von mehreren Methoden, die Argumente in ein Array konvertieren. 

Für mich ist die beste Lösung für kleine Argumente:

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

Für andere Fälle:

function sortArgs (){ return Array.apply(null, arguments).sort(); }
5
Gheljenor

Lodash:

var args = _.toArray(arguments);

in Aktion:

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

produziert:

[2,3]
4
Zane Hooper

Verwenden Sie Array.from() . Dies nimmt ein Array-ähnliches Objekt (wie arguments) als Argument und konvertiert es in ein Array:

(function() {
  console.log(Array.from(arguments));
}(1, 2, 3));

Beachten Sie, dass dies in einigen älteren Browsern wie IE 11 nicht funktioniert. Wenn Sie diese Browser unterstützen möchten, sollten Sie Babel verwenden.

In ECMAScript 6 müssen keine hässlichen Hacks wie Array.prototype.slice() verwendet werden. Sie können stattdessen spread-Syntax (...) verwenden.

(function() {
  console.log([...arguments]);
}(1, 2, 3))

Es mag seltsam aussehen, aber es ist ziemlich einfach. Es extrahiert einfach arguments 'Elemente und fügt sie wieder in das Array ein. Wenn Sie immer noch nicht verstehen, sehen Sie sich diese Beispiele an:

console.log([1, ...[2, 3], 4]);
console.log([...[1, 2, 3]]);
console.log([...[...[...[1]]]]);

Beachten Sie, dass dies in einigen älteren Browsern wie IE 11 nicht funktioniert. Wenn Sie diese Browser unterstützen möchten, sollten Sie Babel verwenden.

Ich empfehle die Verwendung von ECMAScript 6 spread operator , wodurch nachfolgende Parameter an ein Array gebunden werden. Bei dieser Lösung müssen Sie das arguments-Objekt nicht berühren, und Ihr Code wird vereinfacht. Der Nachteil dieser Lösung ist, dass sie in den meisten Browsern nicht funktioniert. Sie müssen stattdessen einen JS-Compiler wie Babel verwenden. Unter der Haube verwandelt Babel arguments in ein Array mit einer for-Schleife. 

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

Wenn Sie kein ECMAScript 6 verwenden können, empfehle ich Ihnen, einige der anderen Antworten wie @Jonathan Fingland zu betrachten

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

 function sortArg(){
    var args = Array.from(arguments); 
    return args.sort();
    }
 
 console.log(sortArg('a', 'b', 1, 2, '34', 88, 20, '19', 39, 'd', 'z', 'ak', 'bu', 90));

3
Abk

Eine andere Antwort.

Verwende schwarze Zaubersprüche:

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

Firefox, Chrome, Node.js, IE11 sind in Ordnung.

Versuchen Sie es mit Object.setPrototypeOf()

Erläuterung: Setzen Sie prototype von arguments auf Array.prototype.

function toArray() {
  return Object.setPrototypeOf(arguments, Array.prototype)
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))


Erläuterung: Nehmen Sie jeden Index von arguments und platzieren Sie das Element in einem Array am entsprechenden Index des Arrays.

könnte alternativ Array.prototype.map() verwenden

function toArray() {
  return [].map.call(arguments, (_,k,a) => a[k])
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))


Erläuterung: Nehmen Sie jeden Index von arguments und platzieren Sie das Element in einem Array am entsprechenden Index des Arrays.

for..of Schleife

function toArray() {
 let arr = []; for (let prop of arguments) arr.Push(prop); return arr
} 

console.log(toArray("abc", 123, {def:456}, [0,[7,[14]]]))


oder Object.create()

Erläuterung: Objekt erstellen, Eigenschaften des Objekts auf Elemente in jedem Index von arguments setzen. setze prototype des erstellten Objekts auf Array.prototype

function toArray() {
  var obj = {};
  for (var prop in arguments) {
    obj[prop] = {
      value: arguments[prop],
      writable: true,
      enumerable: true,
      configurable: true
    }
  } 
  return Object.create(Array.prototype, obj);
}

console.log(toArray("abc", 123, {def: 456}, [0, [7, [14]]]))

1
guest271314

Sie können eine wiederverwendbare Funktion erstellen, um dies mit beliebigen Argumenten zu tun. Die einfachste ist etwa Folgendes: 

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

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

Spread-Syntax kann in ES6 und darüber verwendet werden ... 

Wenn Sie jedoch etwas verwenden möchten, das mit ES5 und darunter kompatibel ist, können Sie Array.prototype.slice.call verwenden, sodass der Code folgendermaßen aussieht:

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

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

Es gibt auch einige andere Möglichkeiten, dies zu tun, beispielsweise mit Array.from oder durchlaufen Sie die arguments und ordnen Sie sie einem neuen Array zu.

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

Ich habe einfache Zerstörungstechniken ausprobiert

0
Gaurav

function sortArgs(...args) {
  return args.sort(function (a, b) { return a - b; });
}

document.body.innerHTML = sortArgs(1, 2, 3, 4).toString();

0
Autumnswind

Das Arguments-Objekt ist nur innerhalb eines Funktionskörpers verfügbar. Obwohl Sie das Argumentobjekt wie ein Array indizieren können, handelt es sich nicht um ein Array. Es hat keine anderen Array-Eigenschaften als length. 

// function arguments length 5
function properties(a,b,c,d,e){
var function_name= arguments.callee.name
var arguments_length= arguments.length;
var properties_length=  properties.length; 
var function_from= properties.caller.name;
console.log('I am the function name: '+ function_name);
console.log('I am the function length, I am function spacific: '+ properties_length); 
console.log('I am the arguments length, I am context/excution spacific: '+ arguments_length);
console.log('I am being called From: '+  function_from );
}

// arguments 3
function parent(){
properties(1,2,3);
}

//arguments length 3 because execution spacific
parent();

Obwohl es wie ein Array indiziert werden kann, wie Sie in diesem Beispiel sehen können: 

function add(){

var sum=0;

for(var i=0; i< arguments.length;i++){

sum = sum + arguments[i];

}

return sum;

}

console.log(add(1,2,3));

Das Arguments-Objekt ist jedoch kein Array und hat keine anderen Eigenschaften als die Länge.

Sie können das Argumentobjekt in ein Array konvertieren, an dem Sie auf das Objekt Arguments zugreifen können. 

Es gibt viele Möglichkeiten, auf das Argumentobjekt innerhalb eines Funktionskörpers zuzugreifen. Dazu gehören: 

  1. sie können die Array.prototoype.slice.call-Methode aufrufen.

Array.prototype.slice.call (Argumente) 

function giveMeArgs(arg1,arg2){

var args = Array.prototype.slice.call(arguments);
return args
}

console.log( giveMeArgs(1,2));

  1. sie können das Array-Literal verwenden 

[] .slice.call (Argumente).

function giveMeArgs(arg1,arg2){

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

return args;

}

console.log( giveMeArgs(1,2) );

  1. sie können Rest verwenden ...

function giveMeArgs(...args){

return args;

}

console.log(giveMeArgs(1,2))

  1. sie können Spread verwenden [...]

function giveMeArgs(){

var args = [...arguments];
return args;

}

console.log(giveMeArgs(1,2));

  1. sie können Array.from () verwenden

function giveMeArgs(){

var args = Array.from(arguments);

return args;

}

console.log(giveMeArgs(1,2));

0
Rick

Hier ist eine saubere und prägnante Lösung:

function argsToArray() {
  return Object.values(arguments);
}

// example usage
console.log(
  argsToArray(1, 2, 3, 4, 5)
  .map(arg => arg*11)
);

Object.values( ) gibt die Werte eines Objekts als Array zurück, und da arguments ein Objekt ist, wird arguments im Wesentlichen in ein Array umgewandelt, sodass Sie alle Hilfsfunktionen eines Arrays wie map, forEach, filter, usw.

0

Obwohl Restparameter gut funktionieren, sollten Sie Folgendes berücksichtigen, wenn Sie arguments weiterhin verwenden möchten

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

[...arguments] kann als eine Art Alternative zu Array.from(arguments) betrachtet werden, die auch perfekt funktioniert. 

Eine ES7-Alternative ist ein Array-Verständnis:

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

Dies ist am einfachsten, wenn Sie die Argumente vor dem Sortieren verarbeiten oder filtern möchten:

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

Benshmarck 3 Methoden:

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);

ERGEBNIS?

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

Genießen !

0
Matrix