Apply suggestions from code review

Co-authored-by: Simone Pasini <66781510+pasor1@users.noreply.github.com>

Author: longo-andrea

1-js/99-js-misc/02-eval/1-eval-calculator/solution.md

@@ -8,4 +8,4 @@ alert( eval(expr) );
 
 L'utente può inserire qualsiasi testo o codice.
 
-Per rendere tutto più sicuro, limitiamo ai soli caratteri aritmetici, possiamo verificare `expr` utilizzando un'[espressione regolare](info:regular-expressions), in questo modo potrà contenere solamente cifre e operatori.
+Per rendere il tutto più sicuro e consentire solo caratteri aritmetici, possiamo verificare `expr` utilizzando un'[espressione regolare](info:regular-expressions), in questo modo la stringa potrà contenere solamente cifre e operatori.

1-js/99-js-misc/02-eval/1-eval-calculator/task.md

@@ -4,7 +4,7 @@ importance: 4
 
 # Eval-calculator
 
-Create una calcolatrice che richiede all'utente (tramite prompt) un'espressione aritmetica e ne ritorni il risultato.
+Create una calcolatrice che richieda all'utente (tramite prompt) un'espressione aritmetica e ne ritorni il risultato.
 
 Non c'è alcun bisogno di testare la correttezza dell'espressione. Limitatevi ad eseguirla e ritornarne il risultato.
 

1-js/99-js-misc/02-eval/article.md

@@ -15,7 +15,7 @@ let code = 'alert("Hello")';
 eval(code); // Hello
 ```
 
-Una stringa di codice potrebbe essere molto lunga, potrebbe contenere interruzioni di riga, dichiarazioni di funzione, variabili e cosi via.
+Una stringa di codice può essere molto lunga, contenere interruzioni di riga, dichiarazioni di funzione, variabili e cosi via.
 
 Il risultato ritornato da `eval` corrisponde a quello dell'ultima istruzione.
 
@@ -30,7 +30,7 @@ let value = eval('let i = 0; ++i');
 alert(value); // 1
 ```
 
-Il codice valutato viene eseguito nel lexical environment corrente, quindi può accedere alle variabili esterne:
+Il codice valutato viene eseguito nel *lexical environment* corrente, quindi può accedere alle variabili esterne:
 
 ```js run no-beautify
 let a = 1;
@@ -46,26 +46,26 @@ function f() {
 f();
 ```
 
-Può quindi modificare le variabili esterne:
+Allo stesso modo, può modificare le variabili esterne:
 
 ```js untrusted refresh run
 let x = 5;
 eval("x = 10");
 alert(x); // 10, valore modificato
 ```
 
-In strict mode, `eval` viene eseguito in un lexical environment separato. Quindi le funzioni e le variabili dichiarate internamente, non sono visibili all'esterno:
+In strict mode, `eval` viene eseguito in un *lexical environment* separato. Quindi le funzioni e le variabili dichiarate internamente, non sono visibili all'esterno:
 
 ```js untrusted refresh run
-// reminder: 'use strict' è abilitato di default negli esempio che stiamo eseguendo
+// attenzione: 'use strict' è abilitato di default negli esempi che stiamo eseguendo
 
 eval("let x = 5; function f() {}");
 
 alert(typeof x); // undefined (variabile inesistente)
 // anche la funzione f non è visibile
 ```
 
-Senza `use strict`, `eval` non viene eseguito in un lexical environment separato, quindi saremo in grado di vedere `x` e `f` dall'esterno.
+Senza `use strict`, `eval` non viene eseguito in un *lexical environment* separato, quindi saremo in grado di vedere `x` e `f` dall'esterno.
 
 ## Utilizzare "eval"
 
@@ -75,9 +75,9 @@ La motivazione è piuttosto semplice: molto tempo fa, JavaScript era un linguagg
 
 Al momento, non esiste alcuna ragione per cui utilizzare `eval`. Se qualcuno lo sta utilizzando, c'è una buona possibilità che questo sia rimpiazzabile con un costrutto del linguaggio oppure con un [modulo JavaScript](info:modules).
 
-Fate attenzione che la sua capacità di accedere alle variabile esterne, può generare side-effects.
+Fate attenzione: la sua capacità di accedere alle variabile esterne può generare side-effects.
 
-I code minifiers (strumenti utilizzati sugli script JS prima di spostarli in produzione, per comprimerli) rinominano le variabili locali con nomi più brevi (come `a`, `b` etc) in modo da rendere il codice più breve. Questa operazione, solitamente, è sicura. Non lo è, però, se stiamo utilizzando `eval`, poiché al suo interno potremmo provare ad accedere alle variabili locali. Quindi i minifiers non rinominano tutte le variabili che sono potenzialmente accessibili da `eval`. Questo comporta una perdita di qualità della compressione del codice.
+I *code minifiers* (strumenti utilizzati per comprimere gli script JS prima di metterli in produzione) rinominano le variabili locali con nomi più brevi (come `a`, `b` etc) in modo da rendere il codice più breve. Questa operazione, solitamente, è sicura. Non lo è, però, se stiamo utilizzando `eval`, poiché al suo interno potremmo provare ad accedere alle variabili locali. Quindi i minifiers non rinominano tutte le variabili che sono potenzialmente accessibili da `eval`. Questo comporta un peggioramento del fattore di compressione del codice.
 
 L'utilizzo delle variabili locali all'interno di `eval` è considerata una bad practice nella programmazione, poiché rende il codice molto più complesso da mantenere.
 
@@ -103,12 +103,12 @@ let f = new Function('a', 'alert(a)');
 f(5); // 5
 ```
 
-Il costrutto `new Function` viene spiegato più nel dettaglio nel capitolo <info:new-function>. Crea una nuova funzione a partire da una stringa, sempre nello scope globale. Quindi può accedere alle variabili locali. Questo è molto più semplice passargliele esplicitamente come argomenti, come nell'esempio visto sopra.
+Il costrutto `new Function`, che viene spiegato più nel dettaglio nel capitolo <info:new-function>, crea una nuova funzione a partire da una stringa. Questa viene creata nel contesto globale, quindi non può accedere alle variabili locali, ma è comunque possibile passargliele esplicitamente come argomenti, come nell'esempio visto sopra.
 
 ## Riepilogo
 
 L'invocazione di `eval(code)` esegue una stringa di codice e ne ritorna il risultato dell'ultima istruzione.
-- Viene raramente utilizzano in JavaScript moderno, quindi in genere non ne avremo bisogno.
+- Viene raramente utilizzato in JavaScript moderno, quindi in genere non ne avremo bisogno.
 - Può accedere alle variabili locali. Questa è considerata una bad practice.
 - Piuttosto di utilzzare `eval` nello scope globale, utilizzate `window.eval(code)`.
-- Oppure, se il codice dovesse avere bisogno di data dallo scope esterno, utilizzate il costrutto `new Function` e passategliele come argomenti.
+- Oppure, se il codice dovesse avere bisogno di dati dallo scope esterno, utilizzate il costrutto `new Function` e passateglieli come argomenti.