diff options
Diffstat (limited to 'files/it/web/javascript/reference/functions')
5 files changed, 1608 insertions, 0 deletions
diff --git a/files/it/web/javascript/reference/functions/arguments/index.html b/files/it/web/javascript/reference/functions/arguments/index.html new file mode 100644 index 0000000000..e879c914e3 --- /dev/null +++ b/files/it/web/javascript/reference/functions/arguments/index.html @@ -0,0 +1,225 @@ +--- +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 = '<' + type + 'l><li>'; + var args = Array.prototype.slice.call(arguments, 1); + result += args.join('</li><li>'); + result += '</li></' + type + 'l>'; // 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: + +"<ul><li>One</li><li>Two</li><li>Three</li></ul>" + +*/</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> diff --git a/files/it/web/javascript/reference/functions/arrow_functions/index.html b/files/it/web/javascript/reference/functions/arrow_functions/index.html new file mode 100644 index 0000000000..eef7570ec0 --- /dev/null +++ b/files/it/web/javascript/reference/functions/arrow_functions/index.html @@ -0,0 +1,395 @@ +--- +title: Funzioni a freccia +slug: Web/JavaScript/Reference/Functions/Arrow_functions +tags: + - ECMAScript6 + - Funzioni + - Intermediate + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Functions/Arrow_functions +original_slug: Web/JavaScript/Reference/Functions_and_function_scope/Arrow_functions +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>Una <strong>funzione a freccia </strong>ha una sintassi più compatta rispetto alla <a href="/it/docs/Web/JavaScript/Reference/Operators/function">notazione a funzione</a> e non associa i propri <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code>, <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>, <a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super</a> o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a>. Le funzioni a freccia sono sempre <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name">anonime</a>. Questa notazione è maggiormente indicata per le funzioni che non sono metodi, e non possono essere usate come costruttori.</p> + +<h2 id="Sintassi">Sintassi</h2> + +<h3 id="Sintassi_di_base">Sintassi di base</h3> + +<pre class="syntaxbox"><strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>) => {</strong> <em>statements</em> <strong>}</strong> +<strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>) =></strong> <em>expression</em> +// equivalente a: <strong>(</strong><em>param1</em>, <em>param2</em>, …, <em>paramN</em><strong>)</strong> => { return <em>expression</em>; } + +// Le Parentesi sono opzionali se è presente un solo parametro: +<em>(singleParam)</em> <strong>=> {</strong> <em>statements</em> <strong>}</strong> +<em>singleParam</em> <strong>=></strong> { <em>statements }</em> + +// Una funzione senza parametri richiede comunque le parentesi: +<strong>() => {</strong> <em>statements</em> <strong>} +</strong>() => <em>expression</em> // equivalente a: () => { return <em>expression</em>; } +</pre> + +<h3 id="Sintassi_avanzata">Sintassi avanzata</h3> + +<pre class="syntaxbox">// Il body tra parentesi indica la restituzione di un oggetto: +<em>params</em> => ({<em>foo: bar</em>}) + +// Sono supportati <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">...rest</a> e <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">i parametri di default</a> +(<em>param1</em>, <em>param2</em>, <strong>...rest</strong>) => { <em>statements</em> } +(<em>param1</em> <strong>= defaultValue1</strong>, <em>param2</em>, …, paramN <strong>= defaultValueN</strong>) => { <em>statements</em> } + +// Si può anche <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destrutturare</a> all'interno della lista dei parametri +var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c; +f(); // 6 +</pre> + +<p>Esempi dettagliati di sintassi sono disponibili <a href="http://wiki.ecmascript.org/doku.php?id=harmony:arrow_function_syntax">qui</a>.</p> + +<h2 id="Descrizione">Descrizione</h2> + +<p>Vedi anche <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" su hacks.mozilla.org</a>.</p> + +<p>L'introduzione delle funzioni a freccia è stata influenzata da due fattori: sintassi più compatta e la non associazione di <code>this</code>.</p> + +<h3 id="Funzioni_più_corte">Funzioni più corte</h3> + +<p>In alcuni pattern, è meglio avere funzioni più corte. Per comparazione:</p> + +<pre class="brush: js">var materials = [ + "Hydrogen", + "Helium", + "Lithium", + "Beryllium" +]; + +materials.map(function(material) { + return material.length; +}); <code>// [8, 6, 7, 9] +</code> +materials.map((material) => { +<code> return material.length; +}); // [8, 6, 7, 9] +</code> +<code>materials.map(material => material.length); // [8, 6, 7, 9]</code></pre> + +<h3 id="Mancato_binding_di_this">Mancato binding di <code>this</code></h3> + +<p>Prima delle funzioni a freccia, ogni nuova funzione definiva il proprio <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code> (un nuovo oggetto nel caso di un costruttore, undefined se una funzione viene chiamata in <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>, l'oggetto di contesto se la funzione viene chiamata come "metodo", etc.). Questo è risultato fastidioso in uno stile di programmazione orientato agli oggetti.</p> + +<pre class="brush: js">function Person() { + // The Person() constructor defines `this` as an instance of itself. + this.age = 0; + + setInterval(function growUp() { + // In non-strict mode, the growUp() function defines `this` + // as the global object, which is different from the `this` + // defined by the Person() constructor. + this.age++; + }, 1000); +} + +var p = new Person();</pre> + +<p>In ECMAScript 3/5, questo problema veniva aggirato assegnando il valore this a una variabile.</p> + +<pre class="brush: js">function Person() { + var that = this; + that.age = 0; + + setInterval(function growUp() { + // The callback refers to the `that` variable of which + // the value is the expected object. + that.age++; + }, 1000); +}</pre> + +<p>In alternativa, poteva essere usato <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">Function.prototype.bind</a> per assegnare il valore corretto di this da usare nella funzione <code>growUp()</code>.</p> + +<p>Una funziona a freccia invece non crea il proprio <code>this</code>, e quindi <code>this</code> mantiene il significato che aveva all'interno dello scope genitore. Perciò il codice seguente funziona come ci si aspetta.</p> + +<pre class="brush: js">function Person(){ + this.age = 0; + + setInterval(() => { + this.age++; // |this| properly refers to the person object + }, 1000); +} + +var p = new Person();</pre> + +<h4 id="Relazione_con_strict_mode">Relazione con strict mode</h4> + +<p>Poiché <code>this</code> è lessicale, le regole di <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> relative a <code>this</code> sono semplicemente ignorate.</p> + +<pre class="brush: js">var f = () => {'use strict'; return this}; +f() === window; // o l'oggetto globale</pre> + +<p>Il resto delle regole si applica normalmente.</p> + +<h4 id="Invocazione_attraverso_call_or_apply">Invocazione attraverso call or apply</h4> + +<p>Poiché <code>this</code><em> </em>non viene assegnato nelle funzioni a freccia, i metodi <code>call()</code><em> </em>o <code>apply()</code> possono passare solo come argomenti; <code>this</code> viene ignorato:</p> + +<pre class="brush: js">var adder = { + base : 1, + + add : function(a) { + var f = v => v + this.base; + return f(a); + }, + + addThruCall: function(a) { + var f = v => v + this.base; + var b = { + base : 2 + }; + + return f.call(b, a); + } +}; + +console.log(adder.add(1)); // This would log to 2 +console.log(adder.addThruCall(1)); // This would log to 2 still</pre> + +<h3 id="Mancato_binding_di_arguments">Mancato binding di <code>arguments</code></h3> + +<p>Le funzioni a freccia non definiscono il proprio <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>. </code>Perciò, <code>arguments</code> è semplicemente una reference alla variabile nello scope genitore.</p> + +<pre class="brush: js">var arguments = 42; +var arr = () => arguments; + +arr(); // 42 + +function foo() { + var f = (i) => arguments[0]+i; // <em>foo</em>'s implicit arguments binding + return f(2); +} + +foo(1); // 3</pre> + +<p>Le funzioni a freccia non hanno il proprio oggetto <code>arguments</code>, ma in molti casi i parametri <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a> rappresentano una valida alternativa:</p> + +<pre class="brush: js">function foo() { + var f = (...args) => args[0]; + return f(2); +} + +foo(1); // 2</pre> + +<h3 id="Funzioni_a_freccia_come_metodi">Funzioni a freccia come metodi</h3> + +<p>Come già citato, le funzioni a freccia sono sconsigliate come metodi. Vediamo cosa succede quando proviamo a usarle: </p> + +<pre class="brush: js">'use strict'; +var obj = { + i: 10, + b: () => console.log(this.i, this), + c: function() { + console.log( this.i, this) + } +} +obj.b(); // prints undefined, Window +obj.c(); // prints 10, Object {...}</pre> + +<p>Le funzioni a freccia non definiscono ("bind") il proprio <code>this</code>. un altro esempio usando {{jsxref("Object.defineProperty()")}}:</p> + +<pre class="brush: js">'use strict'; +var obj = { + a: 10 +}; + +Object.defineProperty(obj, "b", { + get: () => { + console.log(this.a, typeof this.a, this); + return this.a+10; // represents global object 'Window', therefore 'this.a' returns 'undefined' + } +}); +</pre> + +<h3 id="Uso_dell'operatore_new">Uso dell'operatore <code>new</code> </h3> + +<p>Le funzioni a freccia non possono essere usate come costruttori, ed emetteranno un errore se usate con <code>new</code>.</p> + +<h3 id="Uso_di_yield">Uso di <code>yield</code> </h3> + +<p>La keyword <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code> non deve essere usata nel body di una funzione a freccia (eccetto quando permesso in eventuali funzioni al loro interno). Conseguentemente, le funzioni a freccia non possono essere usate come generatori.</p> + +<h2 id="Body_della_funzione">Body della funzione</h2> + +<p>Le funzioni a freccia possono avere un "body conciso" o l'usuale "blocco body".</p> + +<p>Nel primo caso è necessaria solo un'espressione, e il return è implicito. Nel secondo caso, devi usare esplicitamente <code>return</code>.</p> + +<pre class="brush: js">var func = x => x * x; // concise syntax, implied "return" +var func = (x, y) => { return x + y; }; // with block body, explicit "return" needed +</pre> + +<h2 id="Restituire_object_literals">Restituire object literals</h2> + +<p>Tieni a mente che restituire oggetti letterali usando la sintassi concisa <code>params => {object:literal}</code> non funzionerà:</p> + +<pre class="brush: js">var func = () => { foo: 1 }; // Calling func() returns undefined! +var func = () => { foo: function() {} }; // SyntaxError: function statement requires a name</pre> + +<p>Questo perché il codice all'interno delle parentesi graffe ({}) è processato come una sequenza di statement (i.e. <code>foo</code> è trattato come un label, non come una key di un oggetto).</p> + +<p>Tuttavia, è sufficente racchiudere l'oggetto tra parentesi tonde:</p> + +<pre class="brush: js">var func = () => ({ foo: 1 });</pre> + +<h2 id="Newline">Newline</h2> + +<p>Le funzioni a freccia non possono contenere un newline tra i parametri e la freccia.</p> + +<pre class="brush: js">var func = () + => 1; // SyntaxError: expected expression, got '=>'</pre> + +<h2 id="Ordine_di_parsing">Ordine di parsing</h2> + +<p>La freccia in una funziona a freccia non è un'operatore, ma le funzioni a freccia hanno delle regole di parsing specifiche che interagiscono differentemente con <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">la precedenza degli operatori</a>, rispetto alle funzioni normali.</p> + +<pre class="brush: js">let callback; + +callback = callback || function() {}; // ok +callback = callback || () => {}; // SyntaxError: invalid arrow-function arguments +callback = callback || (() => {}); // ok +</pre> + +<h2 id="Altri_esempi">Altri esempi</h2> + +<pre class="brush: js">// Una funzione a freccie vuota restituisce undefined +let empty = () => {}; + +(() => "foobar")() // <a href="/en-US/docs/Glossary/IIFE">IIFE</a>, restituisce "foobar" + +var simple = a => a > 15 ? 15 : a; +simple(16); // 15 +simple(10); // 10 + +let max = (a, b) => a > b ? a : b; + +// Più semplice gestire filtering, mapping, ... di array + +var arr = [5, 6, 13, 0, 1, 18, 23]; +var sum = arr.reduce((a, b) => a + b); // 66 +var even = arr.filter(v => v % 2 == 0); // [6, 0, 18] +var double = arr.map(v => v * 2); // [10, 12, 26, 0, 2, 36, 46] + +// Le catene di promise sono più concise +promise.then(a => { + // ... +}).then(b => { + // ... +}); + +// le funzioni a freccia senza parametri sono più semplici da visualizzare +setTimeout( _ => { + console.log("I happen sooner"); + setTimeout( _ => { + // deeper code + console.log("I happen later"); + }, 1); +}, 1); +</pre> + +<p> </p> + +<p> </p> + +<p> </p> + +<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('ES6', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilità_dei_Browser">Compatibilità dei Browser </h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>IE</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(45.0)}}</td> + <td>{{CompatGeckoDesktop("22.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td> + <p>{{CompatNo}}</p> + </td> + <td>{{CompatOpera(32)}}</td> + <td>{{CompatSafari(10.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(45.0)}}</td> + <td>{{CompatGeckoMobile("22.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari(10.0)}}</td> + <td>{{CompatChrome(45.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Note_specifiche_per_Firefox">Note specifiche per Firefox</h2> + +<ul> + <li>L'implementazione iniziale delle funzioni a freccia in Firefox le rendeva automaticamente strict. Questo è cambiato da <a href="/en-US/docs/Mozilla/Firefox/Releases/24">Firefox 24</a>. L'uso di <code>"use strict";</code> è ora obbligatorio.</li> + <li>Le funzioni a freccia sono semanticamente differenti dalle non-standard {{jsxref("Operators/Expression_Closures", "expression closures", "", 1)}} aggiunte in <a href="/en-US/Firefox/Releases/3">Firefox 3</a> (details: <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.8">JavaScript 1.8</a>), perché {{jsxref("Operators/Expression_Closures", "expression closures", "", 1)}} non assegnano <code>this</code> in modo lessicale.</li> + <li>Fino a <a href="/en-US/Firefox/Releases/39">Firefox 39</a>, un newline (<code>\n</code>) era erroneamente accettato dopo i parametri della funzione. Questo è stato risolto in conformità alle specifiche ES6 e codice come <code>() \n => {}</code> emetterà un {{jsxref("SyntaxError")}} in questa versione e successive.</li> +</ul> + +<h2 id="Vedi_anche">Vedi anche</h2> + +<ul> + <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" on hacks.mozilla.org</a></li> +</ul> diff --git a/files/it/web/javascript/reference/functions/get/index.html b/files/it/web/javascript/reference/functions/get/index.html new file mode 100644 index 0000000000..439255284c --- /dev/null +++ b/files/it/web/javascript/reference/functions/get/index.html @@ -0,0 +1,155 @@ +--- +title: getter +slug: Web/JavaScript/Reference/Functions/get +translation_of: Web/JavaScript/Reference/Functions/get +original_slug: Web/JavaScript/Reference/Functions_and_function_scope/get +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>La sintassi <strong><code>get</code></strong> associa una proprietà dell'oggetto a una funzione che verrà chiamata quando la proprietà verrà richiesta.</p> + +<div>{{EmbedInteractiveExample("pages/js/functions-getter.html")}}</div> + +<p class="hidden">La fonte per questo esempio interattivo è memorizzata in un repository GitHub. Se desideri contribuire ai progetti interattivi di esempio, puoi clonare https://github.com/mdn/interactive-examples e inviarci una richiesta di pull.</p> + +<h2 id="Sintassi">Sintassi</h2> + +<pre class="syntaxbox">{get <em>prop</em>() { ... } } +{get <em>[expression]</em>() { ... } }</pre> + +<h3 id="Parametri">Parametri</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Il nome della proprietà da associare alla funzione specificata.</dd> + <dt>espressione</dt> + <dd>A partire da ECMAScript 2015, è anche possibile utilizzare espressioni per un nome di proprietà calcolato per associarsi alla funzione specificata.</dd> +</dl> + +<h2 id="Descrizione">Descrizione</h2> + +<p>A volte è preferibile consentire l'accesso a una proprietà che restituisce un valore calcolato in modo dinamico, oppure è possibile che si desideri riflettere lo stato di una variabile interna senza richiedere l'uso di chiamate esplicite al metodo. In JavaScript, questo può essere realizzato con l'uso di un <em>getter</em>. Non è possibile avere simultaneamente un getter legato a una proprietà e avere quella proprietà contenuta in un valore, anche se è possibile usare un getter e un setter insieme per creare un tipo di pseudo-proprietà.</p> + +<p>Tieni presente quanto segue quando lavori con la sintassi <code>get</code>:</p> + +<div> +<ul> + <li>Può avere un identificatore che è un numero o una stringa;</li> + <li>Deve avere esattamente zero parametri (vedi <a href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/">Modifica ES5 non compatibile: le funzioni getter e setter letterali devono ora avere esattamente zero o un argomento</a> per maggiori informazioni);</li> + <li>Non deve apparire in un oggetto letterale con un altro <code>get</code> o con un inserimento dati per la stessa proprietà (<code>{ get x() { }, get x() { } }</code> e <code>{ x: ..., get x() { } }</code> sono vietati).</li> +</ul> +</div> + +<p>Un getter può essere rimosso usando l'operatore <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/delete_Operator">delete</a></code></p> + +<h2 id="Esempi">Esempi</h2> + +<h3 id="Definizione_di_un_getter_sui_nuovi_oggetti_negli_inizializzatori_di_oggetti">Definizione di un getter sui nuovi oggetti negli inizializzatori di oggetti</h3> + +<p>Questo creerà una pseudo-proprietà <code>latest</code> più recente per object <code>obj</code>, che restituirà l'ultimo elemento dell'array in <code>log</code>.</p> + +<pre class="brush: js">var obj = { + log: ['example','test'], + get latest() { + if (this.log.length == 0) return undefined; + return this.log[this.log.length - 1]; + } +} +console.log(obj.latest); // "test". +</pre> + +<p>Si noti che il tentativo di assegnare un valore a <code>latest</code> non lo cambierà.</p> + +<h3 id="Cancellare_un_getter_usando_l'operatore_delete">Cancellare un getter usando l'operatore <code>delete</code></h3> + +<p>Se vuoi rimuovere il getter, puoi semplicemente usare <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code> :</p> + +<pre class="brush: js">delete obj.latest; +</pre> + +<h3 id="Definire_un_getter_su_un_oggetto_esistente_usando_defineProperty">Definire un getter su un oggetto esistente usando <code>defineProperty</code></h3> + +<p>Per aggiungere un getter a un oggetto esistente in un secondo momento, usa {{jsxref("Object.defineProperty()")}}.</p> + +<pre class="brush: js">var o = {a: 0}; + +Object.defineProperty(o, 'b', { get: function() { return this.a + 1; } }); + +console.log(o.b) // Runs the getter, which yields a + 1 (which is 1)</pre> + +<h3 id="Utilizzando_un_nome_di_proprietà_calcolato">Utilizzando un nome di proprietà calcolato</h3> + +<pre class="brush: js">var expr = 'foo'; + +var obj = { + get [expr]() { return 'bar'; } +}; + +console.log(obj.foo); // "bar"</pre> + +<h3 id="Smart_self-overwriting_lazy_getters">Smart / self-overwriting / lazy getters</h3> + +<p>I getter ti danno un modo per definire una proprietà di un oggetto, ma non calcolano il valore della proprietà finché non avviene l'accesso. Un getter rinvia il costo del calcolo del valore fino a quando il valore è necessario e, se non è mai necessario, non si paga mai il costo.</p> + +<p>Un'ulteriore tecnica di ottimizzazione per lazificare o ritardare il calcolo di un valore di una proprietà e memorizzarla nella cache per un accesso successivo sono <strong>smart o <a href="https://en.wikipedia.org/wiki/Memoization">memoized</a> getters</strong>. Il valore viene calcolato la prima volta che viene chiamato il getter e viene quindi memorizzato nella cache in modo che gli accessi successivi restituiscano il valore memorizzato nella cache senza ricalcolarlo. Questo è utile nelle seguenti situazioni:</p> + +<ul> + <li>Se il calcolo di un valore di una proprietà è costoso (richiede molta RAM o tempo di CPU, genera thread di lavoro, recupera file remoto, ecc.).</li> + <li>Se il valore non è necessario solo ora. Sarà usato più tardi, o in alcuni casi non è usato affatto.</li> + <li>Se viene utilizzato, sarà accessibile più volte e non è necessario ricalcolare il valore che non verrà mai modificato o non dovrebbe essere ricalcolato.</li> +</ul> + +<p>Ciò significa che non si dovrebbe usare un getter pigro per una proprietà il cui valore si prevede possa cambiare, poiché il getter non ricalcola il valore.</p> + +<p>Nell'esempio seguente, l'oggetto ha un getter come proprietà propria. Quando si ottiene la proprietà, la proprietà viene rimossa dall'oggetto e riaggiunta, ma questa volta implicitamente come proprietà dei dati. Alla fine il valore viene restituito.</p> + +<pre class="brush: js">get notifier() { + delete this.notifier; + return this.notifier = document.getElementById('bookmarked-notification-anchor'); +},</pre> + +<p>Per il codice di Firefox, vedere anche il modulo del codice XPCOMUtils.jsm, che definisce la funzione <code><a href="/en-US/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a></code>.</p> + +<h2 id="Specificazioni">Specificazioni</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('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definizione iniziale.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Aggiunti nomi di proprietà calcolate.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilità_con_il_browser">Compatibilità con il browser</h2> + + + +<p>{{Compat("javascript.functions.get")}}</p> + +<h2 id="Guarda_anche">Guarda anche</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li> + <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> in JavaScript Guide</li> +</ul> diff --git a/files/it/web/javascript/reference/functions/index.html b/files/it/web/javascript/reference/functions/index.html new file mode 100644 index 0000000000..935190e355 --- /dev/null +++ b/files/it/web/javascript/reference/functions/index.html @@ -0,0 +1,618 @@ +--- +title: Funzioni +slug: Web/JavaScript/Reference/Functions +translation_of: Web/JavaScript/Reference/Functions +original_slug: Web/JavaScript/Reference/Functions_and_function_scope +--- +<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 (=>)</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]) => { + statements +} + +param => 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 => 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 <= 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> diff --git a/files/it/web/javascript/reference/functions/set/index.html b/files/it/web/javascript/reference/functions/set/index.html new file mode 100644 index 0000000000..c9f7e6f3fa --- /dev/null +++ b/files/it/web/javascript/reference/functions/set/index.html @@ -0,0 +1,215 @@ +--- +title: setter +slug: Web/JavaScript/Reference/Functions/set +tags: + - Funzioni + - JavaScript + - setter +translation_of: Web/JavaScript/Reference/Functions/set +original_slug: Web/JavaScript/Reference/Functions_and_function_scope/set +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>Il costrutto sintattico <strong><code>set</code></strong> collega una proprietà di un oggetto ad una funzione che viene chiamata quando si ha un tentativo di modifica di quella proprietà.</p> + +<h2 id="Sintassi">Sintassi</h2> + +<pre class="syntaxbox notranslate">{set <em>prop</em>(<em>val</em>) { . . . }} +{set [expression](<em>val</em>) { . . . }}</pre> + +<h3 id="Parametri">Parametri</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Il nome della proprietà da collegare alla funzione data.</dd> +</dl> + +<dl> + <dt><code>val</code></dt> + <dd>Un alias per la variabile che contiene il valore che si sta cercando di assegnare a <code>prop</code>.</dd> + <dt>expression</dt> + <dd>A partire da ECMAScript 6, è possibile anche usare espressioni per nomi di proprietà computate da collegare alla funzione data.</dd> +</dl> + +<h2 id="Descrizione">Descrizione</h2> + +<p>In JavaScript, un setter può essere utilizzato per eseguire una funzione ogniqualvolta una proprietà specificata sta per essere modificata. I setters sono quasi sempre utilizzati insieme ai getters per creare un tipo di pseudo proprietà. Non è possibile avere un setter su una normale proprietà che contiene un valore.</p> + +<p>Alcune note da considerare quando si utilizza il costrutto sintattico <code>set</code>:</p> + +<div> +<ul> + <li>Può avere un identificatore che può essere od un numero od una stringa;</li> + <li>Deve avere esattamente un parametro(consultare <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Incompatible <abbr title="ECMAScript 5th edition">ES5</abbr> change: literal getter and setter functions must now have exactly zero or one arguments</a> per maggiori informazioni);</li> + <li>Non può apparire in un letterale di un oggetto con un altro set o con un assegnamento per la stessa proprietà.<br> + ( <code>{ set x(v) { }, set x(v) { } }</code> e <code>{ x: ..., set x(v) { } } </code>non sono permessi )</li> +</ul> +</div> + +<p>Un setter può essere eliminato usando l'operatore <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="en-US/docs/JavaScript/Reference/Operators/Special/delete"><code>delete</code></a>.</p> + +<h2 id="Esempi">Esempi</h2> + +<h3 id="Definire_un_setter_per_nuovi_oggetti_in_inizializzatori_di_oggetti">Definire un setter per nuovi oggetti in inizializzatori di oggetti</h3> + +<p>Questo snippet di codice definisce una pseudo proprietà <code>current</code> di un oggetto <code>o </code>che, una volta che vi si assegna un valore, aggiornerà <code>log </code>con quel valore:</p> + +<pre class="brush: js notranslate">var o = { + set current (str) { + this.log[this.log.length] = str; + }, + log: [] +} +</pre> + +<p>Nota che <code>current</code> non è definito ed ogni tentativo di accedervi risulterà in un <code>undefined</code>.</p> + +<h3 id="Rimuovere_un_setter_con_loperatore_delete">Rimuovere un setter con l'operatore <code>delete</code></h3> + +<p>Se vuoi rimuovere il setter usato sopra, puoi semplicemente usare <code>delete</code>:</p> + +<pre class="brush: js notranslate">delete o.current; +</pre> + +<h3 id="Definire_un_setter_su_oggetti_pre-esistenti_usando_defineProperty">Definire un setter su oggetti pre-esistenti usando <code>defineProperty</code></h3> + +<p>Per aggiungere un setter ad un oggetto pre-esistente, usa{{jsxref("Object.defineProperty()")}}.</p> + +<pre class="brush: js notranslate">var o = { a:0 }; + +Object.defineProperty(o, "b", { set: function (x) { this.a = x / 2; } }); + +o.b = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property +console.log(o.a) // 5</pre> + +<h3 id="Usare_il_nome_di_una_proprietà_computata">Usare il nome di una proprietà computata</h3> + +<div class="note"> +<p><strong>Nota:</strong> Le proprietà computate sono una tecnologia sperimentale<em>,</em> parte dello standard proposto ECMAScript 6, e non sono ancora sufficientemente supportate dai browsers. L'uso di queste proprietà in ambienti che non le supportano produrrà un errore di sintassi.</p> +</div> + +<pre class="brush: js notranslate">var expr = "foo"; + +var obj = { + baz: "bar", + set [expr](v) { this.baz = v; } +}; + +console.log(obj.baz); // "bar" +obj.foo = "baz"; // run the setter +console.log(obj.baz); // "baz" +</pre> + +<h2 id="Specifiche">Specifiche</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specifica</th> + <th scope="col">Status</th> + <th scope="col">Commento</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definizione iniziale.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Aggiunti i nomi di proprietà computate.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilità_dei_browsers">Compatibilità dei browsers</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Caratteristica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Supporto base</td> + <td>{{CompatChrome(1)}}</td> + <td>{{ CompatGeckoDesktop("1.8.1") }}</td> + <td>{{ CompatIE(9) }}</td> + <td>9.5</td> + <td>3</td> + </tr> + <tr> + <td>Nomi di proprietà computate</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoDesktop("34") }}</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>Caratteristica</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>Supporto base</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("1.8.1") }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Nomi di proprietà computate</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("34.0") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Note_specifiche_per_SpiderMonkey">Note specifiche per SpiderMonkey</h2> + +<ul> + <li>A partire da<a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.8.1"> JavaScript 1.8.1</a>, i setters non sono più chiamati durante il setting delle properietà negli inizializzatori di oggetti od array.</li> + <li>A partire da SpiderMonkey 38, un setter con {{jsxref("Functions/rest_parameters", "rest parameter", "", 1)}} produce un {{jsxref("SyntaxError")}} come da specifica ES6.</li> +</ul> + +<h2 id="Guarda_anche">Guarda anche</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li> + <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> nella guida JavaScript</li> +</ul> |