path: root/files/de/web/javascript/reference/functions/arguments/index.html

---
title: Arguments object
slug: Web/JavaScript/Reference/Functions/arguments
tags:
  - Functions
  - JavaScript
  - Reference
  - arguments
translation_of: Web/JavaScript/Reference/Functions/arguments
---
<div>
<div>
<div>{{jsSidebar("Functions")}}</div>
</div>
</div>

<p>Das <strong><code>arguments</code></strong>-Objekt ist ein Array-ähnliches Objekt, das auf die übergebenen Parameter einer Funktion verweist.</p>

<div>{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}</div>



<h2 id="Syntax">Syntax</h2>

<pre class="syntaxbox notranslate">arguments</pre>

<h2 id="Description" name="Description">Beschreibung</h2>

<p>Das <code>arguments</code>-Objekt ist eine lokal verfügbare Variable in allen (Nicht-Pfeil-) Funktionen. Man kann auf die Parameter einer Funktion referenzieren, wenn man in einer Funktion das <code>arguments</code>-Objekt benutzt. Dieses Objekt enthält einen Eintrag für jeden übergebenen Parameter der Funktion. Der erste Eintrag beginnt beim Index 0. Wenn einer Funktion drei Parameter übergeben werden, kann wie folgt auf diese zugegriffen werden;</p>

<pre class="brush: js notranslate">arguments[0]
arguments[1]
arguments[2]
</pre>

<p>Die Parameter können auch überschrieben werden:</p>

<pre class="brush: js notranslate">arguments[1] = 'new value';</pre>

<p>Das <code>arguments</code>-Objekt ist kein {{jsxref("Array")}}. Es ist ähnlich wie ein <code>Array</code>, hat aber keine Eigenschaften eines <code>Array</code>s mit <span class="dpf_sent" id="dpfsent_1">Ausnahme </span>von {{jsxref("Functions/arguments/length", "length")}}. Zum Beispiel ist die {{jsxref("Global_Objects/Array/pop", "pop")}}-Methode nicht vorhanden. Jedoch kann <code>arguments</code> zu einem echten <code>Array</code> konvertiert werden:</p>

<pre class="brush: js notranslate">var args = Array.prototype.slice.call(arguments);
var args = [].slice.call(arguments);

// ES2015
const args = Array.from(arguments);</pre>

<div class="warning">
<p>Der Einsatz von slice auf arguments kann Optimierungen bei einigen JavaScript-Engines (z. B. bei V8 — <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">mehr Informationen</a>) verhindern. Wenn man sich darum kümmert, sollte ein neues Array erstellt werden, indem über das arguments-Objekt iteriert wird. Eine Alternative ist der Einsatz von <code>Array.apply</code> wie folgt:</p>

<pre class="brush: js notranslate">var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));)</pre>
</div>

<p>Man kann das <code>arguments</code>-Objekt nutzen, um eine Funktion mit mehr übergebenen Parametern, als die der formalen Definition, zu verarbeiten. Diese Technik ist hilfreich für Funktionen mit variabler Parameteranzahl. Man kann {{jsxref("Functions/arguments/length", "arguments.length")}} nutzen, um die Anzahl der übergebenen Parameter festzustellen und dann jeden Parameter über das <code>arguments</code>-Objekt zu verarbeiten. (Um die Anzahl der deklarierten Parameter festzustellen, kann die {{jsxref("Functions/length", "Funktion.length")}} Eigenschaft genutzt werden.)</p>

<h3 id="Einsatz_von_typeof_bei_arguments">Einsatz von <code>typeof</code> bei arguments</h3>

<p>Der Typ von <code>arguments</code> ist <code>'object'</code></p>

<pre class="brush: js notranslate">console.log(typeof arguments); // 'object'</pre>

<p>Der Typ von individuellen Argumenten kann über den Index ermittelt werden.</p>

<pre class="brush: js notranslate">console.log(typeof arguments[0]); // Gibt den Typ des individuellen Arguments zurück</pre>

<h3 id="Einsatz_der_Spread_Syntax_mit_arguments">Einsatz der Spread Syntax mit arguments</h3>

<p>Man kann die {{jsxref("Array.from()")}} Methode oder den <a href="/de/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> nutzen, um arguments zu einem echten Array zu konvertieren:</p>

<pre class="brush: js notranslate">var args = Array.from(arguments);
var args = [...arguments];</pre>

<h2 id="Properties" name="Properties">Eigenschaften</h2>

<dl>
 <dt>{{jsxref("Functions/arguments/callee", "arguments.callee")}}</dt>
 <dd>Referenz zur aktuell ausgeführten Funktion.</dd>
 <dt>{{jsxref("Functions/arguments/caller", "arguments.caller")}} {{ Obsolete_inline() }}</dt>
 <dd>Referenz zur Funktion, die die aktuelle Funktion ausführt hat.</dd>
 <dt>{{jsxref("Functions/arguments/length", "arguments.length")}}</dt>
 <dd>Anzahl der übergebenen Funktionsparameter.</dd>
 <dt>{{jsxref("Functions/arguments/@@iterator", "arguments[@@iterator]")}}</dt>
 <dd>Gibt ein Array-Iterator-Objekt zurück, welches die Werte an allen Indizes von arguments enthält.</dd>
</dl>

<h2 id="Examples" name="Examples">Beispiele</h2>

<h3 id="Example_Defining_function_that_concatenates_several_strings" name="Example:_Defining_function_that_concatenates_several_strings">Definition einer Funktion, die mehrere Strings <span class="dpf_sent" id="dpfsent_1">konkateniert</span></h3>

<p>Dieses Beispiel definiert eine Funktion, die mehrere Strings <span class="dpf_sent" id="dpfsent_1">konkateniert</span>. Der einzige formale Parameter der Funktion ist ein String, der die Zeichen enthält, die die einzelnen Elemente trennt. Die Funktion ist wie folgt definiert:</p>

<pre class="brush:js notranslate">function myConcat(separator) {
  var args = Array.prototype.slice.call(arguments, 1);
  return args.join(separator);
}</pre>

<p>Man kann eine beliebige Anzahl von Parametern der Funktion <span class="dpf_sent" id="dpfsent_0">übergeben</span> und es wird jedes Argument für den String eingesetzt.</p>

<pre class="brush:js notranslate">// returns "red, orange, blue"
myConcat(", ", "red", "orange", "blue");

// returns "elephant; giraffe; lion; cheetah"
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// returns "sage. basil. oregano. pepper. parsley"
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");</pre>

<h3 id="Example_Defining_a_function_that_creates_HTML_lists" name="Example:_Defining_a_function_that_creates_HTML_lists">Definition einer Funktion, die HTML-Listen erstellt</h3>

<p>Im Beispiel wird eine Funktion definiert, die einen String mit HTML für eine Liste zurückgibt. Der einzige formale Parameter der Funktion ist ein String, der "<code>u</code>" für eine ungeordnete Liste oder "<code>o</code>" für eine geordnete Liste enthält. Die Funktion ist wie folgt definiert:</p>

<pre class="brush:js notranslate">function list(type) {
  var result = "&lt;" + type + "l&gt;&lt;li&gt;";
  var args = Array.prototype.slice.call(arguments, 1);
  result += args.join("&lt;/li&gt;&lt;li&gt;");
  result += "&lt;/li&gt;&lt;/" + type + "l&gt;"; // end list

  return result;
}</pre>

<p>Der Funktion kann eine variable Anzahl an Parametern übergeben werden und es wird jeder Parameter als Listeneintrag einer Liste hinzugefügt. Zum Beispiel:</p>

<pre class="brush:js notranslate">var listHTML = list("u", "One", "Two", "Three");

/* listHTML is:

"&lt;ul&gt;&lt;li&gt;One&lt;/li&gt;&lt;li&gt;Two&lt;/li&gt;&lt;li&gt;Three&lt;/li&gt;&lt;/ul&gt;"

*/</pre>

<h3 id="Rest_default_und_Destrukturierende_Parameter">Rest, default und Destrukturierende Parameter</h3>

<p>Das <code>arguments</code>-Objekt kann in Verbindung mit <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, und <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierenden</a> Parametern eingesetzt werden.</p>

<pre class="brush: js notranslate">function foo (...args) {
  return args;
}
foo(1, 2, 3); // [1,2,3]</pre>

<p>Wenn der Einsatz von <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, und <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierenden</a> Parametern nicht die <a href="/de/docs/Web/JavaScript/Reference/Strict_mode#Making_eval_and_arguments_simpler">die Eigenschaften des <code>arguments</code> Objekts verändert, gibt es eine Unterschied zwischen dem strict mode</a> und dem nicht strict mode.</p>

<p>Wenn eine nicht-strikte (non-strict) Funktion nicht  <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende</a> Parameter enthält, referenzieren die Werte des <code>arguments</code> Objektes direkt auf die deklarierten Parameter und umgekehrt. Siehe dazu folgenden Quelltext:</p>

<pre class="brush: js notranslate">function func (a) {
  arguments[0] = 99; // Aktualisert auch arguments[0] und a
  console.log(a);
}
func(10); // 99</pre>

<p>und</p>

<pre class="brush: js notranslate">function func (a) {
  a = 99; // Aktualisert auch arguments[0] und a
  console.log(arguments[0]);
}
func(10); // 99</pre>

<p>Wenn eine nicht-strikte (non-strict) Funktion <a href="/de/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/de/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrukturierende</a> Parameter enthält, referenzieren die Werte des <code>arguments</code> Objektes <strong>nicht</strong> direkt auf die deklarierten Parameter und umgekehrt. Die Werte in <code>arguments</code> sind die Werte, die der Funktion beim Aufruf übergeben werden:</p>

<pre class="brush: js notranslate">function func(a = 55) {
  arguments[0] = 99; // aktualisert arguments[0] aber nicht a
  console.log(a);
}
func(10); // 10</pre>

<p>und</p>

<pre class="brush: js notranslate">function func(a = 55) {
  a = 99; // aktualisert a aber nicht arguments[0]
  console.log(arguments[0]);
}
func(10); // 10;</pre>

<p>und</p>

<pre class="brush: js notranslate">function func(a = 55) {
  console.log(arguments[0]);
}
func(); // undefined;</pre>

<h2 id="Spezifikationen">Spezifikationen</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Spezifikation</th>
   <th scope="col">Status</th>
   <th scope="col">Kommentar</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Initiale Definition. Implementiert in JavaScript 1.1</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Browserkompatibilität">Browserkompatibilität</h2>



<p>{{Compat("javascript.functions.arguments")}}</p>

<h2 id="See_also" name="See_also">Siehe auch</h2>

<ul>
 <li>{{jsxref("Function")}}</li>
</ul>