Merge branch 'master' of https://github.com/javascript-tutorial/en.javascript.info

� Conflicts:
�	1-js/02-first-steps/04-variables/article.md
�	1-js/06-advanced-functions/04-var/article.md
�	2-ui/2-events/02-bubbling-and-capturing/article.md

Author: mehradsadeghi

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

@@ -10,8 +10,8 @@ true + false = 1
 "4" - 2 = 2
 "4px" - 2 = NaN
 7 / 0 = Infinity
-" -9  " + 5 = " -9  5" // (3)
-" -9  " - 5 = -14 // (4)
+"  -9  " + 5 = "  -9  5" // (3)
+"  -9  " - 5 = -14 // (4)
 null + 1 = 1 // (5)
 undefined + 1 = NaN // (6)
 " \t \n" - 2 = -2 // (7)

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -16,36 +16,40 @@ x = (a !== null && a !== undefined) ? a : b;
 
 Here's a longer example.
 
-Let's say, we have a `firstName`, `lastName` or `nickName`, all of them optional.
+Imagine, we have a user, and there are variables `firstName`, `lastName` or `nickName` for their first name, last name and the nick name. All of them may be undefined, if the user decided not to enter any value.
 
-Let's choose the defined one and show it (or "Anonymous" if nothing is set):
+We'd like to display the user name: one of these three variables, or show "Anonymous" if nothing is set.
+
+Let's use the `??` operator to select the first defined one:
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// show the first not-null/undefined variable
+// show the first not-null/undefined value
+*!*
 alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
+*/!*
 ```
 
 ## Comparison with ||
 
-That's very similar to OR `||` operator. Actually, we can replace `??` with `||` in the code above and get the same result.
+The OR `||` operator can be used in the same way as `??`. Actually, we can replace `??` with `||` in the code above and get the same result, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
 
 The important difference is that:
 - `||` returns the first *truthy* value.
 - `??` returns the first *defined* value.
 
 This matters a lot when we'd like to treat `null/undefined` differently from `0`.
 
-For example:
+For example, consider this:
 
 ```js
 height = height ?? 100;
 ```
 
-This sets `height` to `100` if it's not defined. But if `height` is `0`, then it remains "as is".
+This sets `height` to `100` if it's not defined.
 
 Let's compare it with `||`:
 
@@ -56,17 +60,19 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-Here, `height || 100` treats zero height as unset, same as `null`, `undefined` or any other falsy value, depeding on use cases that may be incorrect.
+Here, `height || 100` treats zero height as unset, same as `null`, `undefined` or any other falsy value. So the result is `100`.
+
+The `height ?? 100` returns `100` only if `height` is exactly `null` or `undefined`. So the `alert` shows the height value `0` "as is".
 
-The `height ?? 100` returns `100` only if `height` is exactly `null` or `undefined`.
+Which behavior is better depends on a particular use case. When zero height is a valid value, then `??` is preferrable.
 
 ## Precedence
 
 The precedence of the `??` operator is rather low: `7` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
-That's lower than most operators and a bit higher than `=` and `?`.
+So `??` is evaluated after most other operations, but before `=` and `?`.
 
-So if we need to use `??` in a complex expression, then consider adding parentheses:
+If we need to choose a value with `??` in a complex expression, then consider adding parentheses:
 
 ```js run
 let height = null;
@@ -78,27 +84,34 @@ let area = (height ?? 100) * (width ?? 50);
 alert(area); // 5000
 ```
 
-Otherwise, if we omit parentheses, then `*` has the higher precedence and would run first. That would be the same as:
+Otherwise, if we omit parentheses, `*` has the higher precedence than `??` and would run first.
+
+That would work be the same as:
 
 ```js
-// not correct
+// probably not correct
 let area = height ?? (100 * width) ?? 50;
 ```
 
-There's also a related language-level limitation. Due to safety reasons, it's forbidden to use `??` together with `&&` and `||` operators.
+There's also a related language-level limitation.
+
+**Due to safety reasons, it's forbidden to use `??` together with `&&` and `||` operators.**
 
 The code below triggers a syntax error:
 
 ```js run
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
-The limitation is surely debatable, but for some reason it was added to the language specification.
+The limitation is surely debatable, but it was added to the language specification with the purpose to avoid programming mistakes, as people start to switch to `??` from `||`.
 
-Use explicit parentheses to fix it:
+Use explicit parentheses to work around it:
 
 ```js run
+*!*
 let x = (1 && 2) ?? 3; // Works
+*/!*
+
 alert(x); // 2
 ```
 

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

@@ -285,7 +285,7 @@ Of course, a team can always write their own style guide, but usually there's no
 
 Some popular choices:
 
-- [Google JavaScript Style Guide](https://google.github.io/styleguide/javascriptguide.xml)
+- [Google JavaScript Style Guide](https://google.github.io/styleguide/jsguide.html)
 - [Airbnb JavaScript Style Guide](https://github.com/airbnb/javascript)
 - [Idiomatic.JS](https://github.com/rwaldron/idiomatic.js)
 - [StandardJS](https://standardjs.com/)

1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js

@@ -1,5 +1,11 @@
 describe("test", function() {
+  
+   // Mocha usually waits for the tests for 2 seconds before considering them wrong
+  
+  this.timeout(200000); // With this code we increase this - in this case to 200,000 milliseconds
 
+  // This is because of the "alert" function, because if you delay pressing the "OK" button the tests will not pass!
+  
   before(() => alert("Testing started – before all tests"));
   after(() => alert("Testing finished – after all tests"));
 

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -138,7 +138,7 @@ alert(`${guest} ${admin}`); // Pete Jane (successfully swapped!)
 Here we create a temporary array of two variables and immediately destructure it in swapped order.
 
 We can swap more than two variables this way.
-```
+
 
 ### The rest '...'
 

1-js/06-advanced-functions/02-rest-parameters-spread/article.md

@@ -227,7 +227,7 @@ So, for the task of turning something into an array, `Array.from` tends to be mo
 
 ## Get a new copy of an array/object
 
-Remember when we talked about `Object.assign()` [in the past](https://javascript.info/object#cloning-and-merging-object-assign)?
+Remember when we talked about `Object.assign()` [in the past](info:object-copy#cloning-and-merging-object-assign)?
 
 It is possible to do the same thing with the spread syntax.
 

1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/solution.js

@@ -0,0 +1,3 @@
+function byField(fieldName){
+  return (a, b) => a[fieldName] > b[fieldName] ? 1 : -1;
+}

1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/source.js

@@ -0,0 +1,5 @@
+function byField(fieldName){
+
+  // Your code goes here.
+
+}

1-js/06-advanced-functions/03-closure/9-sort-by-field/_js.view/test.js

@@ -0,0 +1,39 @@
+describe("byField", function(){
+
+  let users = [
+    { name: "John", age: 20, surname: "Johnson" },
+    { name: "Pete", age: 18, surname: "Peterson" },
+    { name: "Ann", age: 19, surname: "Hathaway" },
+  ];
+
+  it("sorts users by name", function(){
+    let nameSortedKey = [
+      { name: "Ann", age: 19, surname: "Hathaway" },
+      { name: "John", age: 20, surname: "Johnson"},
+      { name: "Pete", age: 18, surname: "Peterson" },
+    ];
+    let nameSortedAnswer = users.sort(byField("name"));
+    assert.deepEqual(nameSortedKey, nameSortedAnswer);
+  });
+
+  it("sorts users by age", function(){
+    let ageSortedKey = [
+      { name: "Pete", age: 18, surname: "Peterson" },
+      { name: "Ann", age: 19, surname: "Hathaway" },
+      { name: "John", age: 20, surname: "Johnson"},
+    ];
+    let ageSortedAnswer = users.sort(byField("age"));
+    assert.deepEqual(ageSortedKey, ageSortedKey);
+  });
+
+  it("sorts users by surname", function(){
+    let surnameSortedKey = [
+      { name: "Ann", age: 19, surname: "Hathaway" },
+      { name: "John", age: 20, surname: "Johnson"},
+      { name: "Pete", age: 18, surname: "Peterson" },
+    ];
+    let surnameSortedAnswer = users.sort(byField("surname"));
+    assert.deepEqual(surnameSortedAnswer, surnameSortedKey);
+  });
+
+});

1-js/06-advanced-functions/03-closure/9-sort-by-field/solution.md

@@ -1,22 +1 @@
 
-
-```js run
-let users = [
-  { name: "John", age: 20, surname: "Johnson" }, 
-  { name: "Pete", age: 18, surname: "Peterson" },
-  { name: "Ann", age: 19, surname: "Hathaway" }
-];
-
-*!*
-function byField(field) {
-  return (a, b) => a[field] > b[field] ? 1 : -1;
-}
-*/!*
-
-users.sort(byField('name'));
-users.forEach(user => alert(user.name)); // Ann, John, Pete
-
-users.sort(byField('age'));
-users.forEach(user => alert(user.name)); // Pete, Ann, John
-```
-