Merge branch 'master' of github.com:javascript-tutorial/en.javascript.info into sync-c3a11c85

Author: iliakan

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

@@ -6,7 +6,7 @@ In JavaScript they are written like this:
 
 - 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.
+- 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>.
 
 In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities. 

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

@@ -40,8 +40,7 @@ AND'ing the whole path to the property ensures that all components exist, but is
 
 The optional chaining `?.` stops the evaluation and returns `undefined` if the part before `?.` is `undefined` or `null`.
 
-Further in this article, for brevity, we'll be saying that something "exists" if it's not `null` and not `undefined`.
-
+**Further in this article, for brevity, we'll be saying that something "exists" if it's not `null` and not `undefined`.**
 
 Here's the safe way to access `user.address.street`:
 
@@ -57,14 +56,14 @@ Reading the address with `user?.address` works even if `user` object doesn't exi
 let user = null;
 
 alert( user?.address ); // undefined
-
 alert( user?.address.street ); // undefined
-alert( user?.address.street.anything ); // undefined
 ```
 
-Please note: the `?.` syntax works exactly where it's placed, not any further.
+Please note: the `?.` syntax makes optional the value before it, but not any further.
+
+In the example above, `user?.` allows only `user` to be `null/undefined`.
 
-In the last two lines the evaluation stops immediately after `user?.`, never accessing further properties. But if the `user` actually exists, then the further intermediate properties, such as `user.address` must exist.
+On the other hand, if `user` does exist, then it must have `user.address` property, otherwise `user?.address.street` gives an error at the second dot.
 
 ```warn header="Don't overuse the optional chaining"
 We should use `?.` only where it's ok that something doesn't exist.
@@ -74,14 +73,14 @@ For example, if according to our coding logic `user` object must be there, but `
 So, if `user` happens to be undefined due to a mistake, we'll know about it and fix it. Otherwise, coding errors can be silenced where not appropriate, and become more difficult to debug.
 ```
 
-````warn header="The variable before `?.` must exist"
-If there's no variable `user`, then `user?.anything` triggers an error:
+````warn header="The variable before `?.` must be declared"
+If there's no variable `user` at all, then `user?.anything` triggers an error:
 
 ```js run
 // ReferenceError: user is not defined
 user?.address;
 ```
-The optional chaining only tests for `null/undefined`, doesn't interfere with any other language mechanics.
+There must be `let/const/var user`. The optional chaining works only for declared variables. 
 ````
 
 ## Short-circuiting