Merge branch 'master' into js/12-async-iterators-generators

Author: longo-andrea

1-js/01-getting-started/1-intro/article.md

@@ -4,16 +4,16 @@ Vediamo cosa rende JavaScript così speciale, cosa è possibile ottenere tramite
 
 ## Cos'è JavaScript?
 
-*JavaScript* è stato creato con lo scopo di *"dare vita alle pagine web"*.
+*JavaScript* è stato creato con lo scopo di "dare vita alle pagine web".
 
 I programmi che sfruttano questo linguaggio vengono chiamati *script*. Possono essere scritti direttamente nel documento HTML ed eseguiti in automatico al caricamento della pagina.
 
 Gli script vengono scritti ed eseguiti come testo semplice. Infatti non richiedono particolari conoscenze, ne di essere compilati per poterli eseguire.
 
 In questo aspetto, JavaScript è molto differente da un altro linguaggio chiamato [Java](https://en.wikipedia.org/wiki/Java_(programming_language)).
 
-```smart header="Perchè <u>Java</u>Script?"
-In origine JavaScript aveva un altro nome: "Live Script". In quel periodo Java era molto popolare, per questo si è pensato che identificare questo linguaggio come il "fratello minore" di Java potesse aiutare nella sua diffusione.
+```smart header="Perchè si chiama <u>Java</u>Script?"
+In origine JavaScript aveva un altro nome: "LiveScript". In quel periodo Java era molto popolare, per questo si è pensato che identificare questo linguaggio come il "fratello minore" di Java potesse aiutare nella sua diffusione.
 
 Evolvendosi, JavaScript è diventato un linguaggio completamente indipendente, con delle specifiche personali chiamate [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript), e adesso non ha quasi nulla in comune con Java.
 ```
@@ -26,7 +26,7 @@ Esistono altri motori JavaScript, tra cui:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- per Chrome e Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- per Firefox.
-- ...Ci sono altri codenames come "Trident" e "Chakra" compatibili cond diverse versioni di IE, "ChakraCore" specifico per Microsoft Edge, "Nitro" e "SquirrelFish" per Safari, etc.
+- ...Ci sono altri codenames come "Chakra" per IE, "ChakraCore" specifico per Microsoft Edge, "Nitro" e "SquirrelFish" per Safari, etc.
 
 I nomi citati sopra possono essere utili da ricordare, poichè si possono trovare spesso in articoli che trattano di sviluppo web. Anche noi li useremo. Ad esempio, se "una caratteristica X è supportata da V8", probabilmente funzioneranno senza problemi in Chrome e Opera.
 
@@ -64,7 +64,7 @@ Le possibilità di JavaScript nel browser sono limitate per la sicurezza dell'ut
 
 Degli esempi di queste restrizioni possono essere:
 
-- JavaScript in una pagina web non può leggere o scrivere in qualsiasi file nell'hard disk, ne copiare o eseguire programmi. Non ha accesso diretto alle funzioni di sistema.
+- JavaScript in una pagina web non può leggere o scrivere in qualsiasi file nell'hard disk, ne copiare o eseguire programmi. Non ha accesso diretto alle funzioni di sistema operativo.
 
     I moderni browser gli consentono di lavorare con i file, sempre con un accesso limitato e comunque solo se il comando proviene da utente, come il "dropping" di un file nella finestra del browser, o con la selezione  tramite il tag `<input>`.
 

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

@@ -0,0 +1,42 @@
+
+# Manuali e Specifiche
+
+Questo libro è un *tutorial*. L'obiettivo è quello di aiutarti ad apprender il linguaggio gradualmente. Una volta che avrai familiarizzato con le basi avrai bisogno di ulteriori risorse.
+
+## Specifiche
+
+[La specifica ECMA-262](https://www.ecma-international.org/publications/standards/Ecma-262.htm) contiene informazioni più dettagliate, approfondite e formalizzate riguardo JavaScript. E' la definizione stessa del linguaggio.
+
+Iniziare a studiare dalla formalizzazione può risultare difficile all'inizio. Quindi se avete bisogno di una sorgente affidabile e formale riguardo i dettagli del linguaggio, la specifica è il posto in cui cercare. Ma non è una risorsa comoda da consultare per i problemi di tutti i giorni.
+
+Ogni anno viene rilasciata una nuova specifica. Fra questi rilasci, è possibile trovare l'ultima bozza a <https://tc39.es/ecma262/>.
+
+Per leggere delle più recenti caratteristiche, incluse quelle considerate "quasi standard" (definite "stage 3"), potete consultare <https://github.com/tc39/proposals>.
+
+Inoltre, se state sviluppando in ambiente browser, ci sono ulteriori specifiche che verranno analizzate nella [seconda parte](info:browser-environment) del tutorial.
+
+## 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`.
+
+
+- **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/>.
+
+    Possiamo anche effettuare una ricerca online con frasi come "RegExp MSDN" o "RegExp MSDN jscript".
+
+## Tabelle di compatibilità
+
+JavaScript è un linguaggio in via di sviluppo, per questo nuove funzionalità vengono aggiunte regolarmente.
+
+Per verificare il loro supporto da parte dei browser, si possono consultare:
+
+- <http://caniuse.com> - per visualizzare tabelle di supporto per ogni caratteristica, ad esempio per visualizzare le funzioni di crittografia: <http://caniuse.com/#feat=cryptography>.
+- <https://kangax.github.io/compat-table> - una tabella con le caratteristiche del linguaggio e i motori che le supportano.
+
+Tutte le risorse elencate finora sono utili nella sviluppo di tutti i giorni, in quanto contengono ottime informazioni riguardo i dettagli del linguaggio, il loro support etc.
+
+Ti consiglio quindi di ricordartele (in alternativa puoi consultare questa pagina), nel caso dovessi avere bisogno di informazioni dettagliate riguardo qualche caratteristica particolare.

1-js/01-getting-started/3-code-editors/article.md

@@ -34,6 +34,7 @@ Nella pratica, gli editor semplici possono avere molti plugin tra cui sintassi a
 Meritano attenzione le seguenti opzioni:
 
 - [Atom](https://atom.io/) (multi-piattaforma, gratuito).
+- [Visual Studio Code](https://code.visualstudio.com/) (multi-piattaforma, gratuito).
 - [Sublime Text](http://www.sublimetext.com) (multi-piattaforma, con prova gratuita).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, gratuito).
 - [Vim](http://www.vim.org/) e [Emacs](https://www.gnu.org/software/emacs/) sono particolarmente carini se si sanno utilizzare.

1-js/01-getting-started/4-devtools/article.md

@@ -9,7 +9,7 @@ Per poter visualizzare gli errori e ricevere altre informazioni utili riguardo g
 Molto spesso gli sviluppatori tendono ad utilizzare Chrome o Firefox poichè questi browser forniscono i migliori strumenti per lo sviluppo. Anche gli altri browser contengono gli strumenti per lo sviluppo, talvolta con caratteristiche speciali, ma più che altro giocano ad "avvicinarsi" a Chrome e Firefox.
 Quindi molte perone hanno un browser "preferito" e utilizzano gli altri solo quando un problema è specifico di quel browser.
 
-Gli strumenti da sviluppatore sono potenti; hanno molte caratteristiche. Prima di tutto, dobbiamo capire come ottenerli, come cercare errori e come eseguire comandi JavaScript.
+Gli strumenti da sviluppatore sono molto potenti; possiedono molte caratteristiche. Prima di tutto, dobbiamo capire come accedervi, come cercare errori e come eseguire comandi JavaScript.
 
 ## Google Chrome
 
@@ -34,6 +34,11 @@ Sotto il messaggio d'errore, c'e un simbolo blu `>`. Questo indica la "riga di c
 
 Adesso possiamo visualizzare gli errori, ed è già abbastanza come inizio. Ritorneremo sugli strumenti di sviluppo più avanti e analizzeremo il debugging più in profondità nel capitolo <info:debugging-chrome>.
 
+```smart header="Multi-line input"
+Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+
+To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+```
 
 ## Firefox, Edge, and others
 

1-js/02-first-steps/01-hello-world/1-hello-alert/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+
+<body>
+
+  <script>
+    alert( "I'm JavaScript!" );
+  </script>
+
+</body>
+
+</html>

1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md

@@ -0,0 +1,2 @@
+
+[html src="index.html"]

1-js/02-first-steps/01-hello-world/article.md

@@ -72,7 +72,7 @@ E' anche possibile fornire un percorso relativo a partire dalla pagina corrente.
 Possiamo anche fornire un URL. Per esempio:
 
 ```html
-<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
 Per integrare più script, utilzzate più volte il tag:

1-js/02-first-steps/03-strict-mode/article.md

@@ -72,7 +72,6 @@ Nel caso in cui non funzioni, la miglior strada da seguire è quella di assicura
 })()
 
 
-
 ## Utilizzare sempre "use strict"
 
 Le differenze tra `"use strict"` contro la modalità di "default" non è ancora stata spiegata.

1-js/02-first-steps/05-types/article.md

@@ -1,5 +1,9 @@
 # Tipi di dato
 
+Un valore in JavaScript ha sempre un tipo specifico. Ad esempio, string o number.
+
+Ci sono otto tipi di base in JavaScript. In questo articolo, vedremo i loro aspetti generali, nei prossimi capitoli parleremo di ognuno di essi in dettaglio.
+
 Una variabile in JavaScript può contenere qualsiasi dato. Una variabile può essere di tipo stringa in un istante e successivamente ricevere un valore numerico:
 
 ```js
@@ -10,9 +14,7 @@ message = 123456;
 
 I linguaggi di programmazione che lo consentono sono detti "dinamicamente tipati", questo significa che ci sono tipi di dato, ma le variabili non sono legate ad un tipo.
 
-Ci sono sette tipi di dato in JavaScript. Qui ne studiamo le basi, nel prossimo capitolo lo entreremo nei dettagli.
-
-## Tipo Numerico
+## Number
 
 ```js
 let n = 123;
@@ -62,14 +64,38 @@ I numeri con valore speciale appartengono formalmente al tipo "numerico". Ovviam
 
 Vedremo di più su come lavorare con i numeri nel capitolo <info:number>.
 
-## Tipo Stringa
+## BigInt
+
+In JavaScript, il tipo "number" non può rappresentare valori interni più grandi di <code>(2<sup>53</sup>-1)</code> (che equivale a `9007199254740991`), o minori di <code>-(2<sup>53</sup>-1)</code>. Questa è una limitazione tecnica dovuta alla loro rappresentazione interna.
+
+Per la maggior parte degli scopi, questo intervallo è sufficiente, ma in alcuni casi potremmo aver bisogno di numeri molto grandi, ad esempio per la crittografia o timestamp con precisione al microsecondo.
+
+Il tipo `BigInt` è stato aggiunto di recente al linguaggio, e consente di rappresentare numeri interi di lunghezza arbitraria.
+
+Un valore di tipo `BigInt` viene creato aggiungendo `n` alla fine del numero:
+
+```js
+// la "n" alla fine del numero indica che è un BigInt
+const bigInt = 1234567890123456789012345678901234567890n;
+```
+
+Poichè i `BigInt` sono utilizzati raramente, non li analizzeremo in questo articolo, ma li vedremo più in dettaglio nel capitolo dedicato <info:bigint>.
+
+
+```smart header="Problemi di compatibilità"
+Attualmente, `BigInt` sono supportati da Firefox/Chrome/Edge/Safari, ma non da IE.
+```
+
+Potete sempre verificare [la tabella di compatibilità di *MDN* BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) per sapere quali versioni dei browser li supportano.
+
+## String
 
 Una stringa in JavaScript deve essere tra apici.
 
 ```js
 let str = "Hello";
 let str2 = 'Single quotes are ok too';
-let phrase = `can embed ${str}`;
+let phrase = `can embed another ${str}`;
 ```
 
 In JavaScript, ci sono 3 tipi di apici. 
@@ -155,19 +181,20 @@ Il significato di `undefined` è che "il valore non è assegnato".
 Se una variabile viene dichiarata, ma non assegnata, il suo valore è esattamente `undefined`:
 
 ```js run
-let x;
+let age;
 
-alert(x); // mostra "undefined"
+alert(age); // mostra "undefined"
 ```
 
 Tecnicamente, è possibile assegnare `undefined` a qualsiasi variabile:
 
 ```js run
-let x = 123;
+let age = 100;
 
-x = undefined;
+// change the value to undefined
+age = undefined;
 
-alert(x); // "undefined"
+alert(age); // "undefined"
 ```
 
 ...Ma non è comunque consigliabile farlo. Normalmente, si utilizza `null` per descrivere un valore "vuoto" o "sconosciuto" della variabile, e `undefined` viene utilizzato solo per i controlli, per verificare se la variabile è stata assegnata.
@@ -198,6 +225,8 @@ typeof undefined // "undefined"
 
 typeof 0 // "number"
 
+typeof 10n // "bigint"
+
 typeof true // "boolean"
 
 typeof "foo" // "string"
@@ -228,6 +257,7 @@ Le ultime tre linee potrebbero richiedere una spiegazione ulteriore:
 Ci sono 7 tipi base in JavaScript.
 
 - `number` per numeri di qualsiasi tipo: interi o in virgola mobile.
+- `bigint` viene utilizzato per definire interi di lunghezza arbitraria.
 - `string` per stringhe. Una stringa può contenere uno o più caratteri, non esiste nessun tipo `character`.
 - `boolean` per `true`/`false`.
 - `null` per valori sconosciuti -- un valore a parte che contiene solo il valore `null`.