Merge pull request #175 from javascript-tutorial/sync-3a0b3f4e

Sync with upstream @ 3a0b3f4

Author: pasor1

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -17,16 +17,13 @@ Inoltre, se state sviluppando in ambiente browser, ci sono ulteriori specifiche
 
 ## Manuali
 
-- **MDN (Mozilla) JavaScript Reference** è un manuale con esempi ed altre informazioni utili. E' ottimo per avere informazioni dettagliate riguardo le funzioni e i metodi del linguaggio.
 
-    Può essere consultato al link <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
-
-    Anche se, è meglio eseguire una ricerca internet. E' sufficiente inserire il termine "MDN" nella stringa da ricercare, e.g. <https://google.com/search?q=MDN+parseInt> per ricercare la funzione `parseInt`.
+- **MDN (Mozilla) JavaScript Reference** è il principale manuale con esempi ed altre informazioni utili. E' ottimo per avere informazioni dettagliate riguardo le funzioni e i metodi del linguaggio.
 
+    Può essere consultato al link <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
-- **MSDN** – Manuale Microsoft con molte informazioni, incluso JavaScript (a cui viene fatto riferimento con il termine JScript). Se si ha bisongo di ottenere qualche informazione specifica per Internet Explorer, meglio consultare la guida: <http://msdn.microsoft.com/>.
+Sebbene spesso sia meglio eseguire una ricerca internet, è' sufficiente inserire il termine "MDN" nella stringa da ricercare, e.g. <https://google.com/search?q=MDN+parseInt> per ricercare la funzione `parseInt`.
 
-    Possiamo anche effettuare una ricerca online con frasi come "RegExp MSDN" o "RegExp MSDN jscript".
 
 ## Tabelle di compatibilità
 

1-js/03-code-quality/02-coding-style/code-style.svg

@@ -14,10 +14,10 @@ Semplicemente una valore "raggiungibile" deve essere accessibile o utilizzabile.
 
     Ad esempio:
 
-    - Variabili locali e parametri correnti della funzione.
-    - Variabili o parametri di altre funzioni che fanno però parte della catena delle chiamate annidate.
+    - Funzioni in esecuzione, i loro parametri e le loro variabi locali.
+    - Funzioni che fanno parte della catena delle chiamate annidate, i loro parametri e le loro variabi locali.
     - Variabili globali.
-    - (ce ne sono altre)
+    - (ce ne sono altri, anche interni)
 
     Questi valori sono detti *radici*.
 

1-js/04-object-basics/03-garbage-collection/article.md

@@ -15,6 +15,11 @@ describe("calculator", function() {
     afterEach(function() {
       prompt.restore();
     });
+    
+    it('the read get two values and saves them as object properties', function () {
+      assert.equal(calculator.a, 2);
+      assert.equal(calculator.b, 3);
+    });
 
     it("the sum is 5", function() {
       assert.equal(calculator.sum(), 5);

1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js

@@ -10,6 +10,11 @@ describe("calculator", function() {
     calculator = new Calculator();
     calculator.read();
   });
+  
+  it("the read method asks for two values using prompt and remembers them in object properties", function() {
+    assert.equal(calculator.a, 2);
+    assert.equal(calculator.b, 3);
+  });
 
   it("when 2 and 3 are entered, the sum is 5", function() {
     assert.equal(calculator.sum(), 5);

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js

@@ -91,7 +91,8 @@ La sintassi presentata in questa sessione viene utilizzata raramente, potete tra
 
 Dentro la funzione, possiamo controllare quando questa viene chiamata con `new` e quando senza, utilizzando una speciale proprietà `new.target`.
 
-Questa risulta vuota per le chiamate normali, mentre contiene la funzione se viene chiamata con  `new`:
+Questa risulta 'undefined' per le chiamate normali, mentre contiene la funzione se viene chiamata con  `new`:
+
 
 ```js run
 function User() {

1-js/04-object-basics/06-constructor-new/article.md

@@ -74,12 +74,12 @@ That's why the optional chaining `?.` was added to the language. To solve this p
 
 ## Optional chaining
 
-The optional chaining `?.` stops the evaluation if the part before `?.` is `undefined` or `null` and returns that part.
+The optional chaining `?.` stops the evaluation if the value before `?.` is `undefined` or `null` and returns `undefined`.
 
 **Further in this article, for brevity, we'll be saying that something "exists" if it's not `null` and not `undefined`.**
 
 In other words, `value?.prop`:
-- is the same as `value.prop` if `value` exists,
+- works as `value.prop`, if `value` exists,
 - otherwise (when `value` is `undefined/null`) it returns `undefined`.
 
 Here's the safe way to access `user.address.street` using `?.`:
@@ -103,7 +103,7 @@ alert( user?.address.street ); // undefined
 
 Please note: the `?.` syntax makes optional the value before it, but not any further.
 
-E.g. in `user?.address.street.name` the `?.` allows `user` to be `null/undefined`, but it's all it does. Further properties are accessed in a regular way. If we want some of them to be optional, then we'll need to replace more `.` with `?.`.
+E.g. in `user?.address.street.name` the `?.` allows `user` to safely be `null/undefined` (and returns `undefined` in that case), but that's only for `user`. Further properties are accessed in a regular way. If we want some of them to be optional, then we'll need to replace more `.` with `?.`.
 
 ```warn header="Don't overuse the optional chaining"
 We should use `?.` only where it's ok that something doesn't exist.
@@ -173,18 +173,16 @@ Then `?.()` checks the left part: if the admin function exists, then it runs (th
 The `?.[]` syntax also works, if we'd like to use brackets `[]` to access properties instead of dot `.`. Similar to previous cases, it allows to safely read a property from an object that may not exist.
 
 ```js run
+let key = "firstName";
+
 let user1 = {
   firstName: "John"
 };
 
-let user2 = null; // Imagine, we couldn't authorize the user
-
-let key = "firstName";
+let user2 = null; 
 
 alert( user1?.[key] ); // John
 alert( user2?.[key] ); // undefined
-
-alert( user1?.[key]?.something?.not?.existing); // undefined
 ```
 
 Also we can use `?.` with `delete`:

1-js/04-object-basics/07-optional-chaining/article.md

@@ -97,7 +97,7 @@ Non ci saranno conflitti, poiché i simboli saranno sempre differenti, anche se
 
 Invece se proviamo ad utilizzare una stringa `"id"` piuttosto del symbol, *otterremo* un conflitto:
 
-```js run
+```js
 let user = { name: "John" };
 
 // il nostro script utilizza la proprietà "id"

1-js/04-object-basics/08-symbol/article.md

@@ -16,21 +16,30 @@ Immaginiamo di dover scrivere 1 milione. La via più ovvia è:
 let billion = 1000000000;
 ```
 
+Possiamo anche usare il carattere underscore `_` come separatore:
+
+```js
+let billion = 1_000_000_000;
+```
+
+Qui il carattere `_` gioca il ruolo di "szucchero sintattico", cioè rende il numero più leggibile. Il motore JavaScript semplicemente ignorerà i caratteri `_` tra le cifre, quindi è come scrive il milione di poco sopra.
+
 Nella vita reale però cerchiamo di evitare di scrivere lunghe file di zeri per evitare errori. E anche perché siamo pigri. Solitamente scriviamo qualcosa del tipo `"1ml"` per un milione o `"7.3ml"` 7 milioni e 300mila. Lo stesso vale per i numeri più grandi.
 
 In JavaScript, possiamo abbreviare un numero inserendo la lettera `"e"` con il numero di zeri a seguire:
 
 ```js run
 let billion = 1e9;  // 1 miliardo, letteralmente: 1 e 9 zeri
 
-alert( 7.3e9 );  // 7.3 miliardo (7,300,000,000)
+alert( 7.3e9 );  // 7.3 miliardi (equivale a 7300000000 o 7_300_000_000)
 ```
 
 In altre parole, `"e"` moltiplica il numero `1` seguito dal numero di zeri dati.
 
+
 ```js
-1e3 = 1 * 1000
-1.23e6 = 1.23 * 1000000
+1e3 = 1 * 1000 // e3 means *1000
+1.23e6 = 1.23 * 1000000 // e6 means *1000000
 ```
 
 Ora proviamo a scrivere qualcosa di molto piccolo. Ad esempio, 1 microsecondo (un milionesimo di secondo): 
@@ -125,7 +134,8 @@ Ci sono diverse funzioni integrate per eseguire questa operazione:
 : Arrotonda per eccesso: `3.1` diventa `4`, e `-1.1` diventa `-1`.
 
 `Math.round`
-: Arrotonda all'intero più vicino: `3.1` diventa `3`, `3.6` diventa `4` e `-1.1` diventa `-1`.
+
+: Arrotonda all'intero più vicino: `3.1` diventa `3`, `3.6` diventa `4`, e `3.5` viene arrotondato anch'esso a `4`.
 
 `Math.trunc` (non supportato da Internet Explorer)
 : Rimuove tutto dopo la virgola decimale senza arrotondare: `3.1` diventa `3`, `-1.1` diventa `-1`.

1-js/05-data-types/02-number/article.md

@@ -166,7 +166,9 @@ let [name1, name2] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
 
 alert(name1); // Julius
 alert(name2); // Caesar
+
 // Gli elementi successivi non vengono assegnati
+
 ```
 
 Se vogliamo anche ottenere tutto ciò che segue, possiamo aggiungere un altro parametro che raccoglie "il resto" utilizzando tre punti `" ... "`: