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

---
title: Oggetto 'arguments'
slug: Web/JavaScript/Reference/Functions/arguments
translation_of: Web/JavaScript/Reference/Functions/arguments
original_slug: Web/JavaScript/Reference/Functions_and_function_scope/arguments
---
<div>
<div>{{jsSidebar("Functions")}}</div>
</div>

<p>L'oggetto <strong><code>arguments</code></strong> è un oggetto <code>Array</code>-like corrispondente agli argomenti passati in una funzione </p>

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

<p class="hidden">Il codice sorgente di questo esempio interattivo è ospitato in un repository di Github.<br>
 Se vuoi contribuire al progetto di esempi interattivi, per favore clona <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>

<h2 id="Sintassi">Sintassi</h2>

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

<h2 id="Descrizione">Descrizione</h2>

<p>L'oggetto <code>arguments</code> è una variabile locale disponibile in tutte le funzioni (non-arrow). Si può fare riferimento agli argomenti di una funzione, al suo interno, usando l'oggetto  <code>arguments</code>. Questo oggetto contiene un elemento per ogni argomento passato alla funzione, il primo elemento è indicizzato a 0. Per esempio, se a una funzione sono passati tre argomenti, ci si può riferire ad essi come segue:</p>

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

<p>Gli argomenti possono anche essere settati:</p>

<pre class="brush: js">arguments[1] = 'nuovo valore';
</pre>

<p>L'oggetto <code>arguments</code> non è un {{jsxref("Array")}}. E' simile a un  <code>Array</code>, ma non ha le proprietà dell'<code>Array,</code> eccetto <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length">length</a></code>. Per esempio, non ha il metodo <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop">pop</a></code>. Tuttavia può essere convertito in un vero <code>Array</code>:</p>

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

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

<div class="warning">
<p class="brush: js">Usare slice su arguments impedisce le ottimizzazioni in alcuni motori JavaScript (per esempio V8 - <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">più informazioni</a>). Se ne avete bisogno, provate a costruire un nuovo array iterando sull'oggetto arguments, piuttosto. Un'alternativa potrebbe essere usare l'odiato costruttore <code>Array</code> come una funzione:</p>

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

<p>Si può usare l'oggetto <code>arguments</code> se si chiama una funzione con più argomenti di quanti la funzione dichiari formalmente di accettare. Questa tecnica è utile per le funzioni cui possono essere passati un numero variabile di argomenti. Si usi <code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code> per determinare il numero di argomenti passati alla funzione, e quindi si processi ogni argomento usando l'oggetto <code>arguments</code>. Per determinare il numero di parametri presenti nella <a href="/en-US/docs/Glossary/Signature/Function">dichiarazione</a> di una funzione, si usi la proprietà <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/length">Function.length</a></code>.</p>

<h3 id="Usare_typeof_con_Arguments">Usare <code>typeof</code> con Arguments</h3>

<p>Il typeof di arguments ritorna 'object'. </p>

<pre>console.log(typeof arguments); // 'object' </pre>

<p>Il typeof di ogni signolo argomento può essere determinato con l'uso degli indici.</p>

<pre>console.log(typeof arguments[0]); //this will return the typeof individual arguments.</pre>

<h3 id="Usare_la_sintassi_Spread_con_Arguments">Usare la sintassi Spread con Arguments</h3>

<p>Come è possibile fare con qualsiasi oggetto Array-like, si può usare il metodo {{jsxref("Array.from()")}} o lo <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> per convertire arguments in un vero Array:</p>

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

<h2 id="Proprietà">Proprietà</h2>

<dl>
 <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee</a></code></dt>
 <dd>Riferimento alla funzione in esecuzione.</dd>
 <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/caller">arguments.caller</a></code> {{ Obsolete_inline() }}</dt>
 <dd>Riferimento alla funzione che ha invocato la funzione in esecuzione.</dd>
 <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length">arguments.length</a></code></dt>
 <dd>Riferimento al numero di argomenti passati alla funzione.</dd>
 <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/@@iterator">arguments[@@iterator]</a></code></dt>
 <dd>Ritorna un nuovo oggetto Array Iterator che contiene i valori per ogni indice in arguments.</dd>
</dl>

<h2 id="Esempi">Esempi</h2>

<h3 id="Definire_una_funzione_che_concatena_divere_stringhe">Definire una funzione che concatena divere stringhe </h3>

<p>Questo esempio definisce una funzione che concatena diverse stringhe. L'unico argomento formale per la funzione è una stringa che specifica il carattere di separazione per gli elementi da concatenare. La funzione si definisce come segue:</p>

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

<p>Si può passare un numero indefinito di argomenti a questa funzione, e lei creerà una lista inserendo ciascun argomento come item della lista. </p>

<pre class="brush:js">// 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="Definire_una_funzione_che_crea_liste_HTML">Definire una funzione che crea liste HTML</h3>

<p>Questo esempio definisce una funzione che crea una stringa contenente l'HTML di una lista. L'unico argomento formale della funzione è una  stringa che è "<code>u</code>" se la lista deve essere ordinata, e "<code>o</code>" se la lista deve essere ordinata (numerata). La funzione è definita come segue:</p>

<pre class="brush:js">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>Si può passare un numero indefinito di argomenti a questa funzione, e lei aggiungerà ogni argomento come un elemento della lista del tipo indicato. Per esempio:</p>

<pre class="brush:js">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="Parametri_rest_default_e_destructured">Parametri rest, default, e destructured</h3>

<p>L'oggetto <code>arguments</code> può essere usato insieme a parametri <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, e <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured</a>.</p>

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

<p>Sebbene la presenza di parametri <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured</a> non altera il <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode#Making_eval_and_arguments_simpler">comportamento dell'oggetto <code>arguments</code> nel codice scritto in strict mode</a>, c'è una sottile differenza tra modalità strict e non-strict.</p>

<p>Quando una funzione non-strict <strong>non</strong> <strong>contiene</strong> parametri <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured</a>, allora i valori nell'oggetto <code>arguments</code>  <strong>tracciano</strong> il valore degli argomenti (e vice versa). Si guardi il codice qui sotto:</p>

<pre class="brush: js">function func(a) {
  arguments[0] = 99; // updating arguments[0] also updates a
  console.log(a);
}
func(10); // 99
</pre>

<p>e</p>

<pre class="brush: js">function func(a) {
  a = 99; // updating a also updates arguments[0]
  console.log(arguments[0]);
}
func(10); // 99
</pre>

<p>Quando una funzione non-strict <strong>contiene</strong> parametri <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured</a>, allora i valori nell'oggetto <code>arguments</code> <strong>non tracciano</strong> il valore degli argomenti (e vice versa). Al contrario, riflettono gli argomenti forniti al momento dell'invocazione:</p>

<pre class="brush: js">function func(a = 55) {
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
func(10); // 10</pre>

<p>e</p>

<pre class="brush: js">function func(a = 55) {
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
func(10); // 10
</pre>

<p>e</p>

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

<h2 id="Specifiche">Specifiche</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Specification</th>
   <th scope="col">Status</th>
   <th scope="col">Comment</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Definizione iniziale. Impelementata 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="Browser_compatibility">Browser compatibility</h2>

<div class="hidden">La tavola delle compatibilità in questa pagina è generata da dati strutturati. Se volete contribuire ai dati, per favore visitate <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e mandateci una pull-request-</div>

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

<h2 id="Si_guardi_anche">Si guardi anche</h2>

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