merging all conflicts

Author: iliakan

.gitignore

@@ -21,3 +21,4 @@ sftp-config.json
 Thumbs.db
 
 
+/svgs

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

@@ -24,11 +24,19 @@ Il browser ha un suo motore JavaScript integrato, chiamato alle volte "JavaScrip
 
 Esistono altri motori JavaScript, tra cui:
 
+<<<<<<< HEAD
 - [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 "Chakra" per IE, "JavaScriptCore", "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.
+=======
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome, Opera and Edge.
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
+
+The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome, Opera and Edge.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ```smart header="Come funzionano questi motori?"
 

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

@@ -31,11 +31,18 @@ In pratica, tuttavia, gli editor semplici possono avere molti plugin, tra cui la
 
 Meritano attenzione le seguenti opzioni:
 
+<<<<<<< HEAD
 - [Atom](https://atom.io/) (*cross-platform*, gratuito).
 - [Visual Studio Code](https://code.visualstudio.com/) (*cross-platform*, gratuito).
 - [Sublime Text](http://www.sublimetext.com) (*cross-platform*, 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.
+=======
+- [Atom](https://atom.io/) (cross-platform, free).
+- [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
+- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ## Non intestarditevi
 

1-js/02-first-steps/04-variables/article.md

@@ -24,7 +24,11 @@ Adesso possiamo inserirci dei dati utilizzando l'operatore di assegnazione `=`:
 let message;
 
 *!*
+<<<<<<< HEAD
 message = 'Hello'; // memorizzazione della stringa
+=======
+message = 'Hello'; // store the string 'Hello' in the variable named message
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 */!*
 ```
 

1-js/02-first-steps/09-comparison/article.md

@@ -7,7 +7,14 @@ Molti operatori di confronto già li conosciamo dalla matematica:
 - Uguaglianza: `a == b` (da notare che il doppio simbolo `=` indica un test di uguaglianza, mentre il simbolo unico `a = b` rappresenta un' assegnazione).
 - Disuguaglianza. In matematica la notazione è <code>&ne;</code>, mentre in JavaScript viene scritto come <code>a != b</code>.
 
+<<<<<<< HEAD
 In questo articolo impareremo più approfonditamente i vari tipi di confronto, come vengono gestiti in JavaScript, incluse alcune importanti peculiarità
+=======
+- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
+- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
+- Not equals: In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ## Il risultato è booleano
 

1-js/02-first-steps/11-logical-operators/article.md

@@ -121,8 +121,16 @@ Questo ci permette alcuni utilizzi interessanti rispetto al "puro e classico OR
 
     Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L'operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, il quale viene ritornato. Il processo è chiamato "valutazione a corto-circuito" perché cerca di concludersi il prima possibile, senza dover elaborare tutti gli operandi. 
 
+<<<<<<< HEAD
     Il logical OR è particolarmente utile quando il secondo argomento causerebbe un *side-effect* come l'assegnazione di una variabile o la chiamata a una funzione.
     Nell'esempio che segue solo il secondo messaggio verrà mostrato. 
+=======
+    It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument.
+
+    The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
+
+    In the example below, only the second message is printed:
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
     ```js run no-beautify
     *!*true*/!* || alert("not printed");

1-js/02-first-steps/13-while-for/article.md

@@ -106,10 +106,19 @@ Esaminiamo l'istruzione `for` parte per parte:
 
 | Parte |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
+<<<<<<< HEAD
 | begin | `i = 0`    | Viene eseguito una volta sola, all'entrata nel ciclo.                          |
 | condition | `i < 3`| Viene controllata prima di ogni iterazione; se falsa, il ciclo si interrompe.|
 | body | `alert(i)`| Viene eseguito fino a quando la condizione è vera.
 | step| `i++`      | Viene eseguito ad ogni iterazione, dopo il corpo, fintato che la condizione è `true`.|
+=======
+| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
+| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
+| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
+| step| `i++`      | Executes after the body on each iteration. |
+
+The general loop algorithm works like this:
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 L'iterazione, generalmente, funziona nel modo seguente:
 ```
@@ -379,7 +388,11 @@ label: {
 }
 ```
 
+<<<<<<< HEAD
 ...Comunque, nel 99.9% dei casi, `break` viene usato nei cicli, come abbiamo visto negli esempi precedenti.
+=======
+...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 La chiamata a `continue` è possibile solo dall'interno di un ciclo
 ````

1-js/02-first-steps/15-function-basics/article.md

@@ -182,7 +182,11 @@ In other words, per chiarire questi termini:
 
 Dichiariamo le funzioni elencando i loro parametri, quindi le chiamiamo passando gli argomenti.
 
+<<<<<<< HEAD
 Nell'esempio sopra, si potrebbe dire: "la funzione `showMessage` è dichiarata con due parametri, quindi viene chiamata con due argomenti: `from` and `"Hello"`".
+=======
+In the example above, one might say: "the function `showMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 ## Valori di default
 

1-js/03-code-quality/02-coding-style/article.md

@@ -301,11 +301,19 @@ La miglior cosa di questi strumenti è che il controllo dello stile in qualche o
 
 Alcuni fra i linter più conosciuti:
 
+<<<<<<< HEAD
 - [JSLint](http://www.jslint.com/) -- uno dei primi linter.
 - [JSHint](http://www.jshint.com/) -- molte più opzioni di JSLint.
 - [ESLint](http://eslint.org/) -- il più recente.
 
 Tutti quelli elencati svolgono molto bene il lavoro. L'autore della guida utilizza [ESLint](http://eslint.org/).
+=======
+- [JSLint](https://www.jslint.com/) -- one of the first linters.
+- [JSHint](https://jshint.com/) -- more settings than JSLint.
+- [ESLint](https://eslint.org/) -- probably the newest one.
+
+All of them can do the job. The author uses [ESLint](https://eslint.org/).
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Molti linter sono integrati negli editor più popolari: è sufficiente attivare il plugin e configurare lo stile desiderato.
 
@@ -335,7 +343,11 @@ Qui un esempio di di un file `.eslintrc`:
 
 La direttiva `"extends"` indica che la configurazione è basata sulla lista dei setting "eslint:recommended". Dopodiché potremo specificare il nostro stile personale.
 
+<<<<<<< HEAD
 E' anche possibile scaricare un set di regole dal web ed estenderle a nostro piacimento. Vedi <http://eslint.org/docs/user-guide/getting-started> per maggiori dettagli riguardo l'installazione.
+=======
+It is also possible to download style rule sets from the web and extend them instead. See <https://eslint.org/docs/user-guide/getting-started> for more details about installation.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 Molti IDE hanno dei linter integrati, che sono comodi ma non sono editabili come ESLint.
 

1-js/04-object-basics/02-object-copy/article.md

@@ -135,7 +135,11 @@ clone.name = "Pete"; // cambiamo la proprietà name
 alert( user.name ); // nell'oggetto originale è rimasto "John"
 ```
 
+<<<<<<< HEAD
 Possiamo anche usare il metodo [Object.assign](mdn:js/Object/assign) .
+=======
+Also we can use the method [Object.assign](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) for that.
+>>>>>>> eda333d423db8ade41f75d2e2d30ea06c7d997ef
 
 La sintassi è: