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

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

<p>Parlando in termini generici, una funzione è un "sottopogramma" che può essere <em>chiamato </em>da un codice esterno (o interno nel caso di ricorsione) alla funzione stessa. Come il programma stesso, una funzione è composta da una sequenza di istruzioni chiamata <em>corpo della funzione</em>. Ad una funzione possono essere <em>passati</em> valori, e la funzione <em>restituisce</em> un valore.</p>

<p>In JavaScript, le funzioni sono oggetti di prima classe, perchè sono dotate di proprietà e di metodi, proprio come qualsiasi altro oggetto. Ciò che le distingue dagli altri oggetti è la possibilità di essere chiamate ( invocate ). Le funzioni sono oggetti di tipo <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function">Function</a></code>.</p>

<p>Per maggiori esempi e spiegazioni, vedere anche <a href="/en-US/docs/Web/JavaScript/Guide/Functions">JavaScript la guida sulle funzioni</a>.</p>

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

<p>Ogni funzione in JavaScript è un oggetto di tipo <code>Function</code>. Vedi la pagina <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" title="The Function constructor creates a new Function object. In JavaScript every function is actually a Function object."><code>Function</code></a> for informazioni su proprietà e metodi dell'oggetto <code>Function</code>.</p>

<p>Le funzioni non sono come le procedure. Una funzione restituisce sempre un valore, mentre una procedura può anche non restituire alcun valore.</p>

<p>Per restituire un valore specifico differente da quello di default, una fuzione deve avere un istruzione <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/return">return</a></code> che specifica il valore di ritorno. Una funzione senza un istruzione di ritorno restituirà il valore di  default. Nel caso di un <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">costruttore</a> invocato con la parola chiave <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code>, il valore di default è il valore del suo parametro <code>this</code>. Per tutte le altre funzioni, il valore di ritorno di default è <code>undefined</code>.</p>

<p>I parametri di una chiamata di funzione sono gli <em>argomenti</em> della funzione. Gli argomenti sono passati alla funzione <em>per valore</em>. Se la funzione cambia il valore di un argomento, questo cambiamento non si riflette globalmente o nella funzione chiamante. Sebbene anche i riferimenti a oggetti siano valori, essi sono speciali: se una funzione cambia le proprietà di un oggetto a cui riferisce, quel cambiamento è visibile anche al di fuori della funzione, come dimostrato nel seguente esempio:</p>

<pre class="brush: js">/* Dichiarazione della funzione 'myFunc' */
function myFunc(theObject) {
   theObject.brand = "Toyota";
 }

 /*
  * Dichiarazione della variabile 'mycar';
  * creazione e inizializzazione di un nuovo Object;
  * associazione alla riferimento 'mycar'
  */
 var mycar = {
   brand: "Honda",
   model: "Accord",
   year: 1998
 };

 /* Logs 'Honda' */
 console.log(mycar.brand);

 /* Passaggio del riferimento dell'oggetto alla funzione */
 myFunc(mycar);

 /*
  * Logs 'Toyota' come il valore della proprietà 'brand'
  * dell'oggetto, come è stato cambiato dalla funzione.
  */
 console.log(mycar.brand);
</pre>

<p>NB: l'oggetto <em>console</em> non è un oggetto standard. Non usatelo in un sito web, poichè potrebbe non funzionare correttamente. Per verificare il funzionamento dell'esempio precedente, usate, piuttosto:</p>

<p>           window.alert(mycar.brand);</p>

<p>La <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">parola chiave <code>this</code></a> non fa riferimento alla funzione attualmente in esecuzione, per questo motivo si deve far riferimento ad oggetti <code>Function</code>  per nome, anche quando all'interno del corpo della funzione stessa.</p>

<h2 id="Definizione_di_funzioni">Definizione di funzioni</h2>

<p>Ci sono diversi modi per definire le funzioni:</p>

<h3 id="La_dichiarazione_di_funzione_(istruzione_function)">La dichiarazione di funzione (istruzione <code>function</code>)</h3>

<p>C'è una speciale sintassi per la dichiarazione di funzioni (per dettagli guarda <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a>):</p>

<pre class="syntaxbox">function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Il nome della funzione</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Il nome di un argomento da passare alla funzione. Una funzione può avere fino a 255 argomenti.</dd>
</dl>

<dl>
 <dt><code>statements</code></dt>
 <dd>Le istruzioni comprese nel corpo della funzione.</dd>
</dl>

<h3 id="L'espressione_di_funzione_(espressione_function)">L'espressione di funzione (espressione <code>function</code>)</h3>

<p>Una espressione di funzione è simile ed ha la stessa sintassi della dichiarazione di funzione (per dettagli guarda <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a>):</p>

<pre class="syntaxbox">function [<em>name</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Il nome della funzione. Può essere omesso, in qual caso la funzione è nota come funzione anonima.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Il nome di un argomento da passare alla funzione. Una funzione può avere fino a 255 argomenti.</dd>
 <dt><code>statements</code></dt>
 <dd>Le istruzioni comprese nel corpo della funzione.</dd>
</dl>

<h3 id="La_dichiarazione_di_funzione_generatrice_(espressione_function*)">La dichiarazione di funzione generatrice (espressione <code>function*</code>)</h3>

<div class="note">
<p><strong>Note:</strong> Le funzioni generatrici sono un tecnologia sperimentale, parte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportate dai browsers.</p>
</div>

<p>C'è una sintassi speciale per le funzioni generatrici (per dettagli vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*" title="The function* declaration (function keyword followed by an asterisk) defines a generator function, which returns a Generator object."><code>function* statement</code></a> ):</p>

<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Nome della funzione.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Nome dell'argomento da passare alla funzione. Una funzione può avere fino a 255 agromenti.</dd>
</dl>

<dl>
 <dt><code>statements</code></dt>
 <dd>Le istruzioni comprese nel corpo della funzione.</dd>
</dl>

<h3 id="L'espressione_di_funzione_generatrice_(espressione_function*)">L'espressione di funzione generatrice (espressione <code>function*</code>)</h3>

<div class="note">
<p><strong>Note:</strong> Le funzioni generatrici sono una tecnologia sperimentale<em>,</em> parte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportamente dai browsers.</p>
</div>

<p>Una espressione di funzione generatrice è similare ed ha la stessa sintassi di una dichiarazione di funzione generatrice (per dettagli vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function*" title="The function* keyword can be used to define a generator function inside an expression."><code>function* expression</code></a> ):</p>

<pre class="syntaxbox">function* [<em>name</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Nome della funzione. Può essere omesso, nel qual caso la funzione è nota come funzione anonima.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>
 <div>Nome dell'argomento da passare alla funzione. Una funzione può avere fino a 255 agromenti.</div>
 </dd>
 <dt><code>statements</code></dt>
 <dd>Le istruzioni comprese nel corpo della funzione.</dd>
</dl>

<h3 id="L'espressione_di_funzione_a_freccia_(>)">L'espressione di funzione a freccia (=&gt;)</h3>

<div class="note">
<p><strong>Note:</strong> L'espressione di funzione a freccia sono una tecnologia sperimentare<em>, </em>parte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportate dai browsers.</p>
</div>

<p>Un' espressione di funzione a freccia ha una sintassi ridotta e lessicalmnete associa il proprio valore this (per dettagli vedere <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a> ):</p>

<pre class="syntaxbox">([param] [, param]) =&gt; {
   statements
}

param =&gt; expression
</pre>

<dl>
 <dt><code>param</code></dt>
 <dd>Il nome di un parametro. È necessario indicare l'assenza di parametri con <code>()</code>. Le parentesi non sono richieste nel caso in cui ci sia solo un parametro (come <code>foo =&gt; 1</code>).</dd>
 <dt><code>statements or expression</code></dt>
 <dd>Molteplici istruzioni devono essere racchiuse tra parentesi. Una singola espressione non necessita di parantesi. <em>expression</em> è anche l'implicito valore restituito dalla funzione.</dd>
</dl>

<h3 id="Il_costruttore_Function">Il costruttore <code>Function</code></h3>

<div class="note">
<p><strong>Nota:</strong> l'utilizzo del costruttore <code>Function</code> per creare funzioni non è raccomandato, poichè richiede che il corpo della funzione sia scritto come stringa, fatto che può comportare una mancata ottimizzazione da parte di alcuni motori javascript e causare altri problemi.</p>
</div>

<p>Come tutti gli altri oggetti, un oggetto <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" title="The Function constructor creates a new Function object. In JavaScript every function is actually a Function object."><code>Function</code></a> può essere creato utilizzando l'operatore <code>new</code>:</p>

<pre class="syntaxbox">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)
</pre>

<dl>
 <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
 <dd>Zero o più nomi da usare come nomi formali di argomenti. Ciascun nome deve essere rappresentato da una stringa testuale che sia conforme alle norme che regolano la definizione di identificatori JavaScript validi, oppure da una lista di stringhe testuali, separate da una virgola; per esempio: "<code>x</code>", "<code>theValue</code>", oppure "<code>a,b</code>".</dd>
</dl>

<dl>
 <dt><code>functionBody</code></dt>
 <dd>Una stringa testuale che contenga le istruzioni Javascript comprese nella definizione della funzione.</dd>
</dl>

<p>Invocare il costruttore <code>Function</code> come funzione ( senza utilizzare l'operatore <code>new</code> ) ha lo stesso effetto di quando lo si invoca come costruttore.</p>

<h3 id="Il_costruttore_GeneratorFunction">Il costruttore <code>GeneratorFunction</code></h3>

<div class="note">
<p><strong>Nota:</strong> le espressioni di funzione a freccia ( arrow function expression ) sono una <em>tecnologia sperimentale,</em> parte della proposta ECMAScript 6, e non sono ancora completamente supportate dai browser.</p>
</div>

<div class="note">
<p><strong>Nota:</strong> il costruttore <code>GeneratorFunction</code> non è un oggetto globale, ma può essere ottenuto dall'istanza della funzione generatrice ( vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction" title="The GeneratorFunction constructor creates a new generator function object. In JavaScript every generator function is actually a GeneratorFunction object."><code>GeneratorFunction</code></a> per maggiori dettagli ).</p>
</div>

<div class="note">
<p><strong>Nota:</strong> l'utilizzo del costruttore <code>GeneratorFunction</code> per creare funzioni non è raccomandato, poichè richiede che il corpo della funzione sia scritto come stringa, fatto che può comportare una mancata ottimizzazione da parte di alcuni motori javascript e causare altri problemi.</p>
</div>

<p>Come tutti gli altri oggetti, un oggetto <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction" title="The GeneratorFunction constructor creates a new generator function object. In JavaScript every generator function is actually a GeneratorFunction object."><code>GeneratorFunction</code></a> può essere creato utilizzando l'operatore <code>new</code>:</p>

<pre class="syntaxbox">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)
</pre>

<dl>
 <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
 <dd>Zero o più nomi da usare come nomi formali di argomenti. Ciascun nome deve essere rappresentato da una stringa testuale che sia conforme alle norme che regolano la definizione di identificatori JavaScript validi, oppure da una lista di stringhe testuali, separate da una virgola; per esempio: "<code>x</code>", "<code>theValue</code>", oppure "<code>a,b</code>".</dd>
</dl>

<dl>
 <dt><code>functionBody</code></dt>
 <dd>Una stringa testuale che contenga le istruzioni Javascript comprese nella definizione della funzione.</dd>
</dl>

<p>Invocare il costruttore <code>Function</code> come funzione ( senza utilizzare l'operatore <code>new</code> ) ha lo stesso effetto di quando lo si invoca come costruttore.</p>

<h2 id="I_parametri_di_una_funzione">I parametri di una funzione</h2>

<div class="note">
<p><strong>Nota:</strong> i parametri di default ed i parametri <em>rest</em> sono <em>tecnologie sperimentali</em><em>,</em> parte della proposta  ECMAScript 6, e non sono ancora completamente supportati dai browser.</p>
</div>

<h3 id="Parametri_di_default">Parametri di default</h3>

<p>La sintassi per definire i valori di default dei parametri di una funzione permette di inizializzare i parametri formali con valori di default, sempre che non venga passato il valore <code>undefined</code> oppure non venga passato alcun valore. Per maggiori dettagli, vedi<a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters"> default parameters</a>.</p>

<h3 id="I_parametri_Rest">I parametri <em>Rest</em></h3>

<p>La sintassi per i parametri <em>rest</em> permette di rappresentare un indefinito numero di argomenti come un array. Per maggiori dettagli, vedi <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>.</p>

<h2 id="L'oggetto_arguments">L'oggetto <code>arguments</code></h2>

<p>È possibile riferirsi agli argomenti di una funzione, all'interno della funzione, utilizzando l'oggetto <code>arguments</code>. Vedi <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p>

<ul>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: un oggetto, strutturato come un array, contenente gli argomenti passati alla funzione in esecuzione.</li>
 <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: la funzione in esecuzione.</li>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : la funzione che ha invocato la funzione in esecuzione.</li>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: il numero degli argomenti passati alla funzione.</li>
</ul>

<h2 id="Definire_metodi">Definire metodi</h2>

<h3 id="Funzioni_Getter_e_setter">Funzioni Getter e setter</h3>

<p>È possibile definire metodi getter ( accessor method: metodi per l'accesso al valore di una variabile privata ) e metodi setter ( mutator method: metodi per la modifica del valore di una variabile privata ) per qulasiasi oggetto standard built-in o per qualsiasi oggetto definito dall'utente che supporti l'aggiunta di nuove proprietà. La sintassi da usare per la definizione di metodi getter e setter utilizza la sintassi per la definizione di valori letterali.</p>

<dl>
 <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></dt>
 <dd>
 <p>Lega ( bind ) una proprietà di un oggetto ad una funzione, che verrà invocata ogni volta in cui si cercherà di leggere il valore di quella proprietà.</p>
 </dd>
 <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></dt>
 <dd>Lega ( bind ) una proprietà di un oggetto alla funzione da invocare ogni volta in cui si cercherà di modificare il valore di quella proprietà.</dd>
</dl>

<h3 id="Sintassi_per_la_definizione_dei_metodi">Sintassi per la definizione dei metodi</h3>

<div class="note">
<p><strong>Nota:</strong> <em>le definizioni dei metodi </em>sono <em>tecnologie sperimentali</em><em>,</em> parte della proposta  ECMAScript 6, e non sono ancora completamente supportate dai browser.</p>
</div>

<p>A partire da ECMAScript 6, è possibile definire propri metodi usando una sintassi più breve, simile alla sintassi usata per i metodi getter e setter. Vedi <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a> per maggiori informazioni.</p>

<pre class="brush: js">var obj = {
  foo() {},
  bar() {}
};</pre>

<h2 id="Il_costruttore_Function_vs._la_dichiarazione_di_funzione_vs._l'espressione_di_funzione"><code>Il costruttore</code> <code>Function</code> vs. la dichiarazione di funzione vs. l'espressione di funzione</h2>

<p>Compara i seguenti esempi:</p>

<p>Una funzione definita con la dichiarazione di funzione<code>:</code></p>

<pre class="brush: js">function multiply(x, y) {
   return x * y;
}
</pre>

<p>Una <em>espressione di funzione</em> di una funzione anonima ( senza nome ), assegnata alla variabile <code>multiply:</code></p>

<pre class="brush: js">var multiply = function(x, y) {
   return x * y;
};
</pre>

<p>Una <em>espressione di funzione</em> di una funzione chiamata <code>func_name</code> , assegnata alla variabile <code>multiply:</code></p>

<pre class="brush: js">var multiply = function func_name(x, y) {
   return x * y;
};
</pre>

<h3 id="Differenze">Differenze</h3>

<p>Tutti e tre gli esempi fanno più o meno la stessa cosa, con qualche piccola differenza:</p>

<p>C'è una differenza tra il nome di una funzione e la variabile alla quale la funzione viene assegnata. Il nome di una funzione non può essere modificato, mentre la variabile alla quale viene assegnata la funzione può essere riassegnata. Il nome di una funzione può essere utilizzato solo all'interno del corpo della funzione. Tentare di utilizzarlo al di fuori del corpo della funzione genererà un errore ( oppure restituirà <code>undefined</code> se il nome della funzione era stato precedentemente dichiarato con un'istruzione <code>var </code>). Per esempio:</p>

<pre class="brush: js">var y = function x() {};
alert(x); // throws an error
</pre>

<p>Il nome di una funzione appare anche quando la funzione viene serializzata usando il metodo <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString">toString applicato alla funzione</a>.</p>

<p>Dall'altro lato, la variabile alla quale viene assegnata la funzione è limitata solo dal suo <em>scope</em>, la cui inclusione è garantita al momento della dichiarazione di funzione.</p>

<p>Come si può vedere dal quarto esempio, il nome della funzione può essere diverso dal nome della variabile alla quale la funzione viene assegnata. I due nomi non hanno alcuna relazione tra loro. Una dichiarazione di funzione crea anche una variabile con lo stesso nome della funzione. Quindi, diversamente dalle funzioni definite attraverso un'espressione di funzione, le funzioni definite attraverso una dichiarazione di funzione offrono la possibilità di accedere ad esse attraverso il loro nome, almeno all'interno dello scope in cui erano state definite.</p>

<p>Una funzione definita con il costruttore '<code>new Function'</code> non possiede un nome. Tuttavia, nel motore JavaScript <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, la forma serializzata della funzione mostra il nome "anonymous". Per esempio, il codice <code>alert(new Function())</code> restituisce:</p>

<pre class="brush: js">function anonymous() {
}
</pre>

<p>Poichè la funzione, in realtà, non ha un nome, <code>anonymous</code> non è una variabile alla quale si potrà accedere, all'interno della funzione. Per esempio, il seguente codice restituirebbe un errore:</p>

<pre class="brush: js">var foo = new Function("alert(anonymous);");
foo();
</pre>

<p>Diversamente da quanto accade con le funzioni definite con espressioni di funzione o con il costruttore <code>Function</code>, una funzione definita con una dichiarazione di funzione può essere usata prima della dichiarazione di funzione stessa. Per esempio:</p>

<pre class="brush: js">foo(); // alerts FOO!
function foo() {
   alert('FOO!');
}
</pre>

<p>Una funzione definita da un'espressione di funzione eredita lo <em>scope</em> corrente. Vale a dire, la funzione forma una chiusura. Dall'altro lato, una funzione definita dal costruttore <code>Function</code> non eredita alcuno <em>scope</em>, se non quello globale ( che eredita qualsiasi funzione ).</p>

<p>Le funzioni definite con espressioni di funzione e dichiarazioni di funzione vengono analizzate ( parsed ) solo una volta, mentre quelle definite con il costruttore <code>Function</code> no. Vale a dire, la stringa testuale del corpo della funzione passata al costruttore <code>Function</code> deve essere analizzata ( parsed ) ogni volta in cui viene invocato il costruttore. Sebbene un'espressione di funzione crei ogni volta una chiusura, il corpo della funzione non viene rianalizzato ( reparsed ), così le espressioni di funzione sono ancora più veloci del "<code>new Function(...)</code>". Quindi, il costruttore <code>Function</code> dovrebbe, generalmente, essere evitato dove possibile.</p>

<p>Occorre tenere presente, tuttavia, che le espressioni di funzione e le dichiarazioni di funzione annidate in una funzione generata dall'analisi ( parsing ) di una stringa del costruttore <code>Function non vengono analizzate ( </code>parsed ) continuamente. Per esempio:</p>

<pre class="brush: js">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.</pre>

<p>Una dichiarazione di funzione è molto facilmente ( e spesso, anche non intenzionalmente ) convertita in un'espressione di funzione. Una dichiarazione di funzione cessa di essere tale quando:</p>

<ul>
 <li>diventa parte di un'espressione</li>
 <li>non è più un "elemento sorgente" di una funzione o dello stesso script. Un "elemento sorgente" ( source element ) è un'istruzione non annidata, presente nello script o nel corpo della funzione:</li>
</ul>

<pre class="brush: js">var x = 0;               // source element
if (x == 0) {            // source element
   x = 10;               // not a source element
   function boo() {}     // not a source element
}
function foo() {         // source element
   var y = 20;           // source element
   function bar() {}     // source element
   while (y == 10) {     // source element
      function blah() {} // not a source element
      y++;               // not a source element
   }
}
</pre>

<h3 id="Examples">Examples</h3>

<pre class="brush: js">// function declaration
function foo() {}

// function expression
(function bar() {})

// function expression
x = function hello() {}


if (x) {
   // function expression
   function world() {}
}


// function declaration
function a() {
   // function declaration
   function b() {}
   if (0) {
      // function expression
      function c() {}
   }
}
</pre>

<h2 id="Definire_una_funzione_in_modo_condizionato">Definire una funzione in modo condizionato</h2>

<p>Le funzioni possono essere definite in modo condizionato, utilizzando sia le istruzioni di funzione ( un'estensione prevista nello standard <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262 Edition 3</a> ), sia il costruttore <code>Function</code>. Da notare, però, che le <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=609832"> istruzioni di funzione non sono più accettate in ES5 </a><span id="summary_alias_container"><span id="short_desc_nonedit_display">strict mode</span></span>. Inoltre, questa funzionalità non funziona bene attraverso più browser, quindi sarebbe meglio non farci affidamento.</p>

<p>Nello script seguente, la funzione <code>zero</code> non verrà mai definita e non potrà mai essere invocata, visto che '<code>if (0)</code>' restituisce sempre false:</p>

<pre class="brush: js">if (0) {
   function zero() {
      document.writeln("This is zero.");
   }
}
</pre>

<p>Se la condizione diventasse '<code>if (1)</code>', la funzione <code>zero</code> verrebbe definita.</p>

<p>Nota: sebbene questo tipo di funzione sembri una dichiarazione di funzione, in realtà siamo di fronte ad una espressione ( o statement, o istruzione ), poichè la dichiarazione è annidata all'interno di un'altra istruzione. Vedi le differenze tra dichiarazioni di funzione ed espressioni di funzione.</p>

<p>Nota: alcuni motori JavaScript, eslcuso <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, trattano, non correttamente, qualsiasi espressione di funzione in modo da assegnare loro un nome, al momento della definizione. Questo comporterebbe che la funzione <code>zero</code> sarebbe comunque definita, anche nell'eventualità che la condizione <code>if restituisse </code>sempre false. Un modo più sicuro per definire le funzioni in modo condizionato è di definirle come funzioni anonime ed assegnarle, poi, ad una variabile:</p>

<pre class="brush: js">if (0) {
   var zero = function() {
      document.writeln("This is zero.");
   }
}
</pre>

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

<h3 id="Restituire_un_numero_formattato">Restituire un numero formattato</h3>

<p>La seguente funzione restituisce ( return ) una stringa contenente la rappresentazione formattata di un numero, completato ( padded ) con degli zero iniziali.</p>

<pre class="brush: js">// This function returns a string padded with leading zeros
function padZeros(num, totalLen) {
   var numStr = num.toString();             // Initialize return value as string
   var numZeros = totalLen - numStr.length; // Calculate no. of zeros
   for (var i = 1; i &lt;= numZeros; i++) {
      numStr = "0" + numStr;
   }
   return numStr;
}
</pre>

<p>Queste istruzioni invocano la funzione padZeros.</p>

<pre class="brush: js">var result;
result = padZeros(42,4); // returns "0042"
result = padZeros(42,2); // returns "42"
result = padZeros(5,4);  // returns "0005"
</pre>

<h3 id="Determinare_l'esistenza_di_una_funzione">Determinare l'esistenza di una funzione</h3>

<p>È possibile determinare se una funzione esiste, utilizzando l'operatore <code>typeof</code>. Nell'esempio seguente, viene eseguito un test per determinare se l'oggetto <code>window</code> ha una proprietà, che sia una funzione, chiamata <code>noFunc</code>. Se così, la funzione verrà utilizzata; in caso contrario, verrà eseguita una qualsiasi altra azione.</p>

<pre class="brush: js"> if ('function' == typeof window.noFunc) {
   // use noFunc()
 } else {
   // do something else
 }
</pre>

<p>Da notare che nel test <code>if</code>  viene usato un riferimento a <code>noFunc</code>  — senza usare le parentesi "()" dopo il nome della funzione: in questo modo, la funzione non viene invocata.</p>

<h2 id="Specifications">Specifications</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>ECMAScript 1st Edition.</td>
   <td>Standard</td>
   <td>Initial definition. Implemented in JavaScript 1.0</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>New: Arrow functions, Generator functions, default parameters, rest parameters</td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#', 'function*')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Initial definition.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Initial definition.</td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Browser compatibility</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Generator function</td>
   <td>39</td>
   <td>{{CompatGeckoDesktop("26.0")}}</td>
   <td>{{CompatUnknown}}</td>
   <td>26</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Arrow function</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoDesktop("22.0")}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Generator function</td>
   <td>{{CompatUnknown}}</td>
   <td>39</td>
   <td>{{CompatGeckoMobile("26.0")}}</td>
   <td>{{CompatUnknown}}</td>
   <td>26</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Arrow function</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoMobile("22.0")}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="See_also">See also</h2>

<ul>
 <li>{{jsxref("Statements/function", "function statement")}}</li>
 <li>{{jsxref("Operators/function", "function expression")}}</li>
 <li>{{jsxref("Statements/function*", "function* statement")}}</li>
 <li>{{jsxref("Operators/function*", "function* expression")}}</li>
 <li>{{jsxref("Function")}}</li>
 <li>{{jsxref("GeneratorFunction")}}</li>
 <li>{{jsxref("Functions/Arrow_functions", "Arrow functions")}}</li>
 <li>{{jsxref("Functions/Default_parameters", "Default parameters")}}</li>
 <li>{{jsxref("Functions/rest_parameters", "Rest parameters")}}</li>
 <li>{{jsxref("Functions/arguments", "Arguments object")}}</li>
 <li>{{jsxref("Functions/get", "getter")}}</li>
 <li>{{jsxref("Functions/set", "setter")}}</li>
 <li>{{jsxref("Functions/Method_definitions", "Method definitions")}}</li>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="JavaScript/Reference/Functions_and_function_scope">Functions and function scope</a></li>
</ul>