Das `arguments`-Objekt
Baseline Widely available *
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
* Some parts of this feature may have varying levels of support.
Das arguments
-Objekt ist ein array-ähnliches Objekt, das innerhalb von Funktionen zugänglich ist und die Werte der an diese Funktion übergebenen Argumente enthält.
Probieren Sie es aus
function func1(a, b, c) {
console.log(arguments[0]);
// Expected output: 1
console.log(arguments[1]);
// Expected output: 2
console.log(arguments[2]);
// Expected output: 3
}
func1(1, 2, 3);
Beschreibung
Hinweis: In modernem Code sollten Rest-Parameter bevorzugt werden.
Das arguments
-Objekt ist eine lokale Variable, die in allen nicht-Arrow Functions verfügbar ist. Sie können in der Funktion auf die Argumente über das arguments
-Objekt zugreifen. Es enthält Einträge für jedes Argument, mit dem die Funktion aufgerufen wurde, wobei der Index des ersten Eintrags 0
ist.
Wenn eine Funktion zum Beispiel mit drei Argumenten aufgerufen wird, können Sie sie wie folgt zugreifen:
arguments[0]; // first argument
arguments[1]; // second argument
arguments[2]; // third argument
Das arguments
-Objekt ist nützlich für Funktionen, die mit mehr Argumenten aufgerufen werden, als formell definiert sind, sogenannte variadic functions wie Math.min()
. In diesem Beispiel wird eine Funktion gezeigt, die eine beliebige Anzahl von String-Argumenten akzeptiert und den längsten zurückgibt:
function longestString() {
let longest = "";
for (let i = 0; i < arguments.length; i++) {
if (arguments[i].length > longest.length) {
longest = arguments[i];
}
}
return longest;
}
Sie können arguments.length
verwenden, um zu zählen, wie viele Argumente mit der Funktion aufgerufen wurden. Wenn Sie stattdessen zählen möchten, wie viele Parameter eine Funktion formal akzeptiert, sollten Sie die length
-Eigenschaft dieser Funktion inspizieren.
Indizes zuweisen
Jeder Argumentindex kann ebenfalls gesetzt oder neu zugewiesen werden:
arguments[1] = "new value";
Nicht-strikte Funktionen mit einfachen Parametern (d. h. ohne Rest-, Default- oder Destructuring-Parameter) synchronisieren den neuen Wert der Parameter mit dem arguments
-Objekt und umgekehrt:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
function func2(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func2(10); // 99
Nicht-strikte Funktionen, die Rest-, Default- oder Destructured-Parameter übergeben bekommen, synchronisieren Änderungen der Parameter-Werte im Funktionskörper nicht mit dem arguments
-Objekt. Stattdessen reflektiert das arguments
-Objekt immer die Werte, die der Funktion beim Aufruf übergeben wurden.
function funcWithDefault(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
funcWithDefault(10); // 10
function funcWithDefault2(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
funcWithDefault2(10); // 10
// An untracked default parameter
function funcWithDefault3(a = 55) {
console.log(arguments[0]);
console.log(arguments.length);
}
funcWithDefault3(); // undefined; 0
Dasselbe Verhalten tritt bei allen Strict-Mode-Funktionen auf, unabhängig von der Art der übergebenen Parameter. Das bedeutet, dass neue Zuweisungen zu Parametern im Funktionskörper das arguments
-Objekt niemals ändern, ebenso wie Zuweisungen zu arguments
-Indizes die Werte der Parameter nicht beeinflussen, auch wenn die Funktion nur einfache Parameter hat.
Hinweis:
Sie können eine "use strict";
-Direktive nicht im Körper einer Funktionsdefinition verwenden, die Rest-, Default- oder Destructured-Parameter akzeptiert. Dies führt zu einem Syntaxfehler.
arguments
ist ein array-ähnliches Objekt
Das arguments
-Objekt ist ein array-ähnliches Objekt, was bedeutet, dass arguments
über eine length
-Eigenschaft und nullbasierte Indizes verfügt, jedoch nicht über die eingebauten Methoden von Array
wie forEach()
oder map()
. Es kann jedoch in ein echtes Array
umgewandelt werden, indem slice()
, Array.from()
oder Spread-Syntax verwendet werden:
const args = Array.prototype.slice.call(arguments);
// or
const args = Array.from(arguments);
// or
const args = [...arguments];
Für häufige Anwendungsfälle reicht es aus, das Objekt als array-ähnliches Objekt zu verwenden, da es sowohl iterierbar ist als auch eine length
-Eigenschaft sowie numerische Indizes besitzt. Zum Beispiel akzeptiert Function.prototype.apply()
array-ähnliche Objekte.
function midpoint() {
return (
(Math.min.apply(null, arguments) + Math.max.apply(null, arguments)) / 2
);
}
console.log(midpoint(3, 1, 4, 1, 5)); // 3
Eigenschaften
arguments.callee
Veraltet-
Verweist auf die aktuell ausgeführte Funktion, zu der die Argumente gehören. In Strict Mode nicht erlaubt.
arguments.length
-
Die Anzahl der Argumente, die an die Funktion übergeben wurden.
arguments[Symbol.iterator]()
-
Gibt ein neues Array-Iterator-Objekt zurück, das die Werte für jeden Index im
arguments
-Objekt enthält.
Beispiele
Definieren einer Funktion, die mehrere Strings verknüpft
Dieses Beispiel definiert eine Funktion, die mehrere Strings verknüpft. Das einzige formale Argument der Funktion ist ein String, der die Zeichen enthält, die die zu verknüpfenden Elemente trennen.
function myConcat(separator) {
const args = Array.prototype.slice.call(arguments, 1);
return args.join(separator);
}
Sie können dieser Funktion beliebig viele Argumente übergeben. Sie gibt eine String-Liste zurück, die jedes Argument in der Liste verwendet:
myConcat(", ", "red", "orange", "blue");
// "red, orange, blue"
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
// "elephant; giraffe; lion; cheetah"
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
// "sage. basil. oregano. pepper. parsley"
Definieren einer Funktion, die HTML-Listen erstellt
Dieses Beispiel definiert eine Funktion, die einen String mit HTML für eine Liste erstellt. Das einzige formale Argument der Funktion ist ein String, der "u"
ist, wenn die Liste eine ungeordnete (mit Punkten) sein soll, oder "o"
, wenn die Liste eine geordnete (nummerierte) sein soll. Die Funktion wird wie folgt definiert:
function list(type) {
let html = `<${type}l><li>`;
const args = Array.prototype.slice.call(arguments, 1);
html += args.join("</li><li>");
html += `</li></${type}l>`; // end list
return html;
}
Sie können dieser Funktion beliebig viele Argumente übergeben, und sie fügt jedes Argument als Listenelement zu einer Liste des angegebenen Typs hinzu. Zum Beispiel:
list("u", "One", "Two", "Three");
// "<ul><li>One</li><li>Two</li><li>Three</li></ul>"
Verwendung von typeof
mit arguments
Der Operator typeof
gibt 'object'
zurück, wenn er mit arguments
verwendet wird.
console.log(typeof arguments); // 'object'
Der Typ einzelner Argumente kann durch Indizieren von arguments
bestimmt werden:
console.log(typeof arguments[0]); // returns the type of the first argument
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-arguments-exotic-objects |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
arguments | ||||||||||||||
[Symbol.iterator] | ||||||||||||||
callee | ||||||||||||||
length |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support
- Deprecated. Not for use in new websites.