merging all conflicts

Author: iliakan

1-js/02-first-steps/08-operators/article.md

@@ -107,7 +107,11 @@ Ora un esempio più complesso:
 alert(2 + 2 + '1' ); // "41" non "221"
 ```
 
+<<<<<<< HEAD
 Qui le operazioni vengo eseguite una di seguito all'altra, da sinistra verso destra. Il primo `+` somma i due numeri e restituisce `4`, quindi il successivo `+` concatena a quest'ultimo la stringa `1`, quindi sarebbe come fare `4 + '1' = 41`.
+=======
+Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = '41'`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 ```js run
 alert('1' + 2 + 2 ); // "122" non "14"

1-js/02-first-steps/14-switch/article.md

@@ -47,7 +47,7 @@ switch (a) {
     break;
 */!*
   case 5:
-    alert( 'Too large' );
+    alert( 'Too big' );
     break;
   default:
     alert( "I don't know such values" );

1-js/03-code-quality/06-polyfills/article.md

@@ -11,7 +11,11 @@ Se si vuole rimanere aggiornati riguardo lo stato di supporto delle caratteristi
 
 Come programmatori, amiamo utilizzare le più recenti caratteristiche del linguaggio!
 
+<<<<<<< HEAD
 Ma come si può fare per farle funzionare sui vecchi motori JavaScript che non le comprendono ed interpretano?
+=======
+On the other hand, how to make our modern code work on older engines that don't understand recent features yet?
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 Esistono due strumenti per questo:
 

1-js/05-data-types/04-array/article.md

@@ -437,9 +437,15 @@ Questo operatore non offre alcun tipo di trattamento speciale per gli array, li
 
 Ricordando velocemente le regole:
 
+<<<<<<< HEAD
 - Due oggetti sono uguali con `==` solamente se fanno riferimento allo stesso oggetto.
 - Se uno dei due argomenti forniti all'operatore `==` è un oggetto, e l'altro è un tipo primitivo, allora l'oggetto viene convertito in primitivo, come spiegato nel capitolo <info:object-toprimitive>.
 - ...Con l'eccezione di `null` e `undefined` che sono uguali solamente tra di loro.
+=======
+- Two objects are equal `==` only if they're references to the same object.
+- If one of the arguments of `==` is an object, and the other one is a primitive, then the object gets converted to primitive, as explained in the chapter <info:object-toprimitive>.
+- ...With an exception of `null` and `undefined` that equal `==` each other and nothing else.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 Il confronto stretto, con l'operatore `===` è ancora più semplice, poiché non converte i tipi. 
 

1-js/05-data-types/10-destructuring-assignment/6-max-salary/_js.view/solution.js

@@ -1,16 +1,14 @@
 function topSalary(salaries) {
 
-  let max = 0;
+  let maxSalary = 0;
   let maxName = null;
 
   for(const [name, salary] of Object.entries(salaries)) {
     if (max < salary) {
-      max = salary;
+      maxSalary = salary;
       maxName = name;
     }
   }
 
   return maxName;
-}
-
-
+}

1-js/09-classes/01-class/article.md

@@ -50,7 +50,13 @@ let user = new User("John");
 user.sayHi();
 ```
 
+<<<<<<< HEAD
 Quando viene chiamato `new User("John")`:
+=======
+When `new User("John")` is called:
+1. A new object is created.
+2. The `constructor` runs with the given argument and assigns it to `this.name`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 1. Viene creato un nuovo oggetto;
 2. Il metodo `constructor()` viene richiamato e assegna a `this.name` l'argomento dato.

1-js/09-classes/02-class-inheritance/article.md

@@ -53,7 +53,11 @@ rabbit.run(5); // White Rabbit runs with speed 5.
 rabbit.hide(); // White Rabbit hides!
 ```
 
+<<<<<<< HEAD
 Ora il codice di `Rabbit` è diventato un po' più corto, dato che utilizza il costruttore di `Animal`, e può anche correre (usare il metodo `run`) come gli animali (animals).
+=======
+Object of `Rabbit` class have access both to `Rabbit` methods, such as `rabbit.hide()`, and also to `Animal` methods, such as `rabbit.run()`.
+>>>>>>> 97ef86242f9f236b13152e1baf52a55c4db8728a
 
 Internamente, `extends` aggiunge da `Rabbit.prototype` un riferimento `[[Prototype]]` a `Animal.prototype`:
 

1-js/09-classes/07-mixins/article.md

@@ -69,7 +69,7 @@ let sayMixin = {
 };
 
 let sayHiMixin = {
-  __proto__: sayMixin, // (or we could use Object.create to set the prototype here)
+  __proto__: sayMixin, // (or we could use Object.setPrototypeOf to set the prototype here)
 
   sayHi() {
     *!*

9-regular-expressions/13-regexp-alternation/03-match-quoted-string/solution.md

@@ -3,7 +3,7 @@ The solution: `pattern:/"(\\.|[^"\\])*"/g`.
 Step by step:
 
 - First we look for an opening quote `pattern:"`
-- Then if we have a backslash `pattern:\\` (we technically have to double it in the pattern, because it is a special character, so that's a single backslash in fact), then any character is fine after it (a dot).
+- Then if we have a backslash `pattern:\\` (we have to double it in the pattern because it is a special character), then any character is fine after it (a dot).
 - Otherwise we take any character except a quote (that would mean the end of the string) and a backslash (to prevent lonely backslashes, the backslash is only used with some other symbol after it): `pattern:[^"\\]`
 - ...And so on till the closing quote.
 

9-regular-expressions/14-regexp-lookahead-lookbehind/1-find-non-negative-integers/solution.md

@@ -1,7 +1,7 @@
 
 The regexp for an integer number is `pattern:\d+`.
 
-We can exclude negatives by prepending it with the negative lookahead: `pattern:(?<!-)\d+`.
+We can exclude negatives by prepending it with the negative lookbehind: `pattern:(?<!-)\d+`.
 
 Although, if we try it now, we may notice one more "extra" result: