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

---
title: eval()
slug: Web/JavaScript/Reference/Global_Objects/eval
translation_of: Web/JavaScript/Reference/Global_Objects/eval
---
<p>{{jsSidebar("Objects")}}</p>

<h2 id="Summary" name="Summary">Riassunto</h2>

<p>Il metodo <code><strong>eval()</strong></code> esegue il codice JavaScript rappresentato come una stringa.</p>

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

<pre class="syntaxbox"><code>eval(<em>stringa</em>)</code></pre>

<h3 id="Parameters" name="Parameters">Parametri</h3>

<dl>
 <dt><code>string</code></dt>
 <dd>Una stringa che rappresenta un'espressione JavaScript, dichiarazione o sequenza di istruzioni. L'espressione può includere le variabili e le proprietà degli oggetti esistenti.</dd>
</dl>

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

<p><code>eval()</code> è una funzione dell'oggetto globale.</p>

<p>L'argomento della funzione <code>eval()</code> è una stringa. Se la stringa rappresenta un'espressione, <code>eval()</code> esegue l'espressione. Se l'argomento rappresenta una o più dichiarazioni Javascript, <code>eval()</code>esegue le dichiarazioni. Non chiamare <code>eval()</code> per eseguire un'operazione aritmetica, JavaScript la esegue automaticamente.</p>

<p>Se si costruisce un'espressione aritmetica come una stringa, è possibile usare <code>eval()</code> per eseguirla in un secondo momento. Ad esempio, supponiamo di avere una variabile <code>x</code>. E' possibile rinviare il valore di un'espressione che coinvolge <code>x</code>  assegnando il valore della stringa dell'espressione, tipo "<code>3 * x + 2</code>", ad una variabile, e quindi chiamare <code>eval()</code> in un punto successivo dello script.</p>

<p>Se l'argomento di <code>eval()</code> non è una stringa, <code>eval()</code> restituisce l'argomento immutato. Nell'esempio qui sotto, il costrutto <code>String</code> viene specificato, e <code>eval()</code> ritorna un oggetto <code>String</code> piuttosto che il risultato della stringa.</p>

<pre class="brush:js">eval(new String("2 + 2")); // returns a String object containing "2 + 2"
eval("2 + 2");             // returns 4
</pre>

<p>E' possibile aggirare questa limitazione in modo generico utilizzando <code>toString()</code>.</p>

<pre class="brush:js">var expression = new String("2 + 2");
eval(expression.toString());
</pre>

<p>Non è possibile utilizzare la funzione <code>eval</code> indirettamente, invocandola con un nome diverso da <code>eval()</code>; se lo fai , potrebbe verificarsi un errore di sintassi. Per esempio, non si dovrebbe usare il seguente codice:</p>

<pre class="brush:js">var x = 2;
var y = 4;
var myEval = eval;
myEval("x + y");
</pre>

<h2 id="Don.27t_use_eval.21" name="Don.27t_use_eval.21"><a name="dont-use-it">Non usate eval inutilmente!</a></h2>

<p><code>eval()</code>è una funzione pericolosa, che esegue il codice con i privilegi dell'amministratore della pagina. Se si esegue <code>eval()</code> con una stringa che potrebbe essere interessata da un malintenzionato, si può interrompere l'esecuzione del codice dannoso sul computer dell'utente con il permesso della pagina Web. Ancora più importante, codici di terze parti possono vedere come <code>eval()</code> è stata invocata, che può portare a possibili attacchi come {{jsxref("Global_Objects/Function", "Function")}}.</p>

<p><code>eval()</code> è generalmente più lenta rispetto alle alternative, dal momento che deve chiamare l'interprete di JS, mentre moltri altri costrutti sono ottimizzati da moderni "motori" JS.</p>

<p>Queste sono alternative più sicure (e veloci! ) ad <code>eval()</code> per comuni impieghi.</p>

<h3 id="Accessing_member_properties" name="Accessing_member_properties">Accesso alle proprietà utente</h3>

<p>Si consiglia si non utilizzare <code>eval()</code> per conventire i nomi di proprietà in proprietà. Consideriamo l'esempio qui sotto, dove le proprietà dell'oggetto acui accedere non è nota fino a quando viene eseguito il codice. Questo può essere fatto con eval:</p>

<pre class="brush:js">var obj = { a: 20, b: 30 };
var propname = getPropName();  //returns "a" or "b"

eval( "var result = obj." + propname );
</pre>

<p>Tuttavia, <code>eval ()</code> non è necessario qui. In realtà, il suo uso è sconsigliato qui. Invece, utilizzare gli <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators" title="JavaScript/Reference/Operators/Member_Operators">operatori membri</a>, che sono molto più veloci e sicuri:</p>

<pre class="brush:js">var obj = { a: 20, b: 30 };
var propname = getPropName();  //returns "a" or "b"
var result = obj[ propname ];  //  obj[ "a" ] is the same as obj.a
</pre>

<h3 id="Use_functions_instead_of_evaluating_snippets_of_code" name="Use_functions_instead_of_evaluating_snippets_of_code">Utilizzare le funzioni invece di eseguire frammenti di codice</h3>

<p>JavaScript ha <a class="external" href="http://en.wikipedia.org/wiki/First-class_function" title="http://en.wikipedia.org/wiki/First-class_function">funzioni di prima classe</a>, il che significa che è possibile passare funzioni come argomenti ad altre API, memorizzarli in variabili e le proprietà degli oggetti, e così via. Molte API DOM sono progettate con questo in mente, in modo da poter (e devono) scrivere a:</p>

<pre class="brush: js">// instead of setTimeout(" ... ", 1000) use:
setTimeout(function() { ... }, 1000);

// instead of elt.setAttribute("onclick", "...") use:
elt.addEventListener("click", function() { ... } , false); </pre>

<p><a href="/en-US/docs/Web/JavaScript/Guide/Closures" title="JavaScript/Guide/Closures">Le chiusure</a> sono utili anche come un modo per creare funzioni parametrizzate senza concatenazioni di stringhe.</p>

<h3 id="Parsing_JSON_(converting_strings_to_JavaScript_objects)" name="Parsing_JSON_(converting_strings_to_JavaScript_objects)">Analisi di JSON (conversione di stringhe in oggetti JavaScript)</h3>

<p>Se la stringa che si sta chiamando <code>eval()</code> contiene dati (per esempio un array: <code>"[1, 2, 3]"</code>), al ontrario del codice, si dovrebbe considerareil passaggio a <a href="/en-US/docs/JSON" title="JSON">JSON</a>, che permette la stringa di utilizzre un sottoinsieme della sintassi Javascript per rappresentare i dati. Vedi anche <a href="/en-US/docs/Downloading_JSON_and_JavaScript_in_extensions" title="Downloading_JSON_and_JavaScript_in_extensions">Downloading JSON and JavaScript in extensions</a>.</p>

<p>Notare che, poichè la sintassi JSON è limitata rispetto alla sintassi di Javascript, molti letterali Javascript validi non analizzare come JSON. Ad esempio, le virgole finali non sono ammessi in JSON, e nomi di proprietà (chiavi) in letterali oggetto devono essere racchiusi tra virgolette. Assicurarsi di utilizzare un serializzatore JSON per generare le stringhe che vrranno successivamente analizzate come JSON.</p>

<h3 id="Pass_data_instead_of_code" name="Pass_data_instead_of_code">Paasare i dati al posto di codici</h3>

<p>Ad esempio, un'estensione progettata per raschiare contenuti delle pagine Web potrebbe avere le regole di raschiatura definite in  <a href="/en-US/docs/XPath" title="XPath">XPath</a> invece di codice Javascript.</p>

<h3 id="Run_code_with_limited_privileges" name="Run_code_with_limited_privileges">Eseguire codice con privilegi limitati</h3>

<p>Se devi eseguire il codice, considerare di eseguirlo con privilegi ridotti. Questo consilio vale soprattutto per le estensioni e le applicazioni XUL, che possono utilizzare  <a href="/en-US/docs/Components.utils.evalInSandbox" title="Components.utils.evalInSandbox">Components.utils.evalInSandbox</a> per questo.</p>

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

<p>Il seguente esempio mostra output utilizzando <a href="/en-US/docs/Web/API/document.write"><code>document.write</code></a>. Nel server-side JavaScript, è possibile visualizzare la stessa uscita chiamando la funzione <code>write()</code> invece di utilizzare il <code>document.write()</code>.</p>

<h3 id="Example:_Using_eval" name="Example:_Using_eval">Esempio: Usare <code>eval</code></h3>

<p>Nel codice seguente, entrambe le dichiarazioni contenenti  <code>eval()</code> restituiscono 42. La prima restituisce la stringa  "<code>x + y + 1</code>" ; la seconda esegue la stringa "<code>42</code>".</p>

<pre class="brush:js">var x = 2;
var y = 39;
var z = "42";
eval("x + y + 1"); // returns 42
eval(z);           // returns 42
</pre>

<h3 id="Example:_Using_eval_to_evaluate_a_string_of_JavaScript_statements" name="Example:_Using_eval_to_evaluate_a_string_of_JavaScript_statements">Esempio: Usare <code>eval</code> Per eseguire una serie di istruzioni JavaScript.</h3>

<p>Il seguente esempio utilizza  <code>eval()</code> per eseguire la stringa <code>str</code>. Questa stringa consiste in una serie di istruzioni JavaScript che aprono una finestra di avviso e assegnano a <code>z</code> un valore 42 se <code>x</code> è di cinque, e assegna 0 a <code>z</code> altrimenti. Quando viene eseguita la seconda istruzione, <code>eval()</code> farà si che questa dichiarazioni da effettuare, e sarà anche eseguire l'insieme di istruzioni e restituire il valore che viene assegnato a <code>z</code>.</p>

<pre class="brush:js">var x = 5;
var str = "if (x == 5) {alert('z is 42'); z = 42;} else z = 0; ";

document.write("&lt;P&gt;z is ", eval(str));</pre>

<h3 id="Return_value" name="Return_value">Esempio: L'ultima espressione viene eseguita</h3>

<p><code>eval()</code>restituisce il valore dell'ultima espressione valutata.</p>

<pre class="brush:js">var str = "if ( a ) { 1+1; } else { 1+2; }";
var a = true;
var b = eval(str);  // returns 2

alert("b is : " + b);

a = false;
b = eval(str);  // returns 3

alert("b is : " + b);</pre>

<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.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-15.1.2.1', 'eval')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-eval-x', 'eval')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </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>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Android</th>
   <th>Chrome per 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>
 </tbody>
</table>
</div>

<h3 id="See_Also" name="See_Also">Gecko-specific notes</h3>

<ul>
 <li>Storicamente <code>eval()</code> ha avuto un secondo argomento opzionale, specificando un oggetto nel cui contesto la valutazione doveva essere eseguita. Questo argomento è stato non-standard, ed è stato rimosso dal SpiderMonkey in Gecko 1.9.1 (Firefox 3.5). Vedere {{ bug(442333) }}.</li>
</ul>

<h2 id="See_Also" name="See_Also">Vedi anche</h2>

<ul>
 <li>{{jsxref("Global_Objects/uneval", "uneval()")}}</li>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators">Member operators</a></li>
</ul>