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

Author: iliakan

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

@@ -309,8 +309,7 @@ for (let i = 0; i < 3; i++) {
 
     let input = prompt(`Value at coords (${i},${j})`, '');
 
-    // what if I want to exit from here to Done (below)?
-
+    // what if we want to exit from here to Done (below)?
   }
 }
 

1-js/04-object-basics/01-object/article.md

@@ -154,7 +154,7 @@ let user = {
 };
 
 let key = "name";
-user.key // undefined
+alert( user.key ) // undefined
 ```
 
 ### Computed properties

1-js/04-object-basics/03-symbol/article.md

@@ -3,11 +3,11 @@
 
 By specification, object property keys may be either of string type, or of symbol type. Not numbers, not booleans, only strings or symbols, these two types.
 
-Till now we've only seen strings. Now let's see the advantages that symbols can give us.
+Till now we've been using only strings. Now let's see the benefits that symbols can give us.
 
 ## Symbols
 
-"Symbol" value represents a unique identifier.
+A "symbol" represents a unique identifier.
 
 A value of this type can be created using `Symbol()`:
 
@@ -52,15 +52,15 @@ alert(id); // TypeError: Cannot convert a Symbol value to a string
 
 That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not occasionally convert one into another.
 
-If we really want to show a symbol, we need to call `.toString()` on it, like here:
+If we really want to show a symbol, we need to explicitly call `.toString()` on it, like here:
 ```js run
 let id = Symbol("id");
 *!*
 alert(id.toString()); // Symbol(id), now it works
 */!*
 ```
 
-Or get `symbol.description` property to get the description only:
+Or get `symbol.description` property to show the description only:
 ```js run
 let id = Symbol("id");
 *!*
@@ -74,15 +74,19 @@ alert(id.description); // id
 
 Symbols allow us to create "hidden" properties of an object, that no other part of code can occasionally access or overwrite.
 
-For instance, if we're working with `user` objects, that belong to a third-party code and don't have any `id` field. We'd like to add identifiers to them.
+For instance, if we're working with `user` objects, that belong to a third-party code. We'd like to add identifiers to them.
 
 Let's use a symbol key for it:
 
 ```js run
-let user = { name: "John" };
+let user = { // belongs to another code
+  name: "John"
+};
+
 let id = Symbol("id");
 
-user[id] = "ID Value";
+user[id] = 1;
+
 alert( user[id] ); // we can access the data using the symbol as the key
 ```
 
@@ -108,13 +112,13 @@ There will be no conflict between our and their identifiers, because symbols are
 ```js run
 let user = { name: "John" };
 
-// our script uses "id" property
-user.id = "ID Value";
+// Our script uses "id" property
+user.id = "Our id value";
 
-// ...if later another script the uses "id" for its purposes...
+// ...Another script also wants "id" for its purposes...
 
 user.id = "Their id value"
-// boom! overwritten! it did not mean to harm the colleague, but did it!
+// Boom! overwritten by another script!
 ```
 
 ### Symbols in a literal
@@ -129,7 +133,7 @@ let id = Symbol("id");
 let user = {
   name: "John",
 *!*
-  [id]: 123 // not just "id: 123"
+  [id]: 123 // not "id: 123"
 */!*
 };
 ```

1-js/05-data-types/05-array-methods/9-shuffle/solution.md

@@ -68,7 +68,13 @@ There are other good ways to do the task. For instance, there's a great algorith
 function shuffle(array) {
   for (let i = array.length - 1; i > 0; i--) {
     let j = Math.floor(Math.random() * (i + 1)); // random index from 0 to i
-    [array[i], array[j]] = [array[j], array[i]]; // swap elements
+
+    // swap elements array[i] and array[j]
+    // we use "destructuring assignment" syntax to achieve that
+    // you'll find more details about that syntax in later chapters
+    // same can be written as:
+    // let t = array[i]; array[i] = array[j]; array[j] = t
+    [array[i], array[j]] = [array[j], array[i]];
   }
 }
 ```

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

@@ -2,13 +2,13 @@
 
 In JavaScript we can only inherit from a single object. There can be only one `[[Prototype]]` for an object. And a class may extend only one other class.
 
-But sometimes that feels limiting. For instance, I have a class `StreetSweeper` and a class `Bicycle`, and want to make their mix: a `StreetSweepingBicycle`.
+But sometimes that feels limiting. For instance, we have a class `StreetSweeper` and a class `Bicycle`, and want to make their mix: a `StreetSweepingBicycle`.
 
 Or we have a class `User` and a class `EventEmitter` that implements event generation, and we'd like to add the functionality of `EventEmitter` to `User`, so that our users can emit events.
 
 There's a concept that can help here, called "mixins".
 
-As defined in Wikipedia, a [mixin](https://en.wikipedia.org/wiki/Mixin) is a class that contains methods for use by other classes without having to be the parent class of those other classes.
+As defined in Wikipedia, a [mixin](https://en.wikipedia.org/wiki/Mixin) is a class containing methods that can be used by other classes without a need to inherit from it.
 
 In other words, a *mixin* provides methods that implement a certain behavior, but we do not use it alone, we use it to add the behavior to other classes.
 

1-js/10-error-handling/1-try-catch/article.md

@@ -298,7 +298,7 @@ try {
 *!*
   alert(e.name); // SyntaxError
 */!*
-  alert(e.message); // Unexpected token o in JSON at position 0
+  alert(e.message); // Unexpected token o in JSON at position 2
 }
 ```
 

1-js/99-js-misc/03-currying-partials/article.md

@@ -40,7 +40,7 @@ As you can see, the implementation is straightforward: it's just two wrappers.
 
 - The result of `curry(func)` is a wrapper `function(a)`.
 - When it is called like `sum(1)`, the argument is saved in the Lexical Environment, and a new wrapper is returned `function(b)`.
-- Then `sum(1)(2)` finally calls `function(b)` providing `2`, and it passes the call to the original multi-argument `sum`.
+- Then this wrapper is called with `2` as an argument, and it passes the call to the original `sum`.
 
 More advanced implementations of currying, such as [_.curry](https://lodash.com/docs#curry) from lodash library, return a wrapper that allows a function to be called both normally and partially:
 
@@ -73,10 +73,15 @@ Let's curry it!
 log = _.curry(log);
 ```
 
-After that `log` work both the normal way and in the curried form:
+After that `log` work normally:
+
+```js
+log(new Date(), "DEBUG", "some debug"); // log(a, b, c)
+```
+
+...But also works in the curried form:
 
 ```js
-log(new Date(), "DEBUG", "some debug"); // log(a,b,c)
 log(new Date())("DEBUG")("some debug"); // log(a)(b)(c)
 ```
 
@@ -102,11 +107,11 @@ debugNow("message"); // [HH:mm] DEBUG message
 
 So:
 1. We didn't lose anything after currying: `log` is still callable normally.
-2. We were able to generate partial functions such as for today's logs.
+2. We can easily generate partial functions such as for today's logs.
 
 ## Advanced curry implementation
 
-In case you'd like to get in details, here's the "advanced" curry implementation that we could use above.
+In case you'd like to get in details, here's the "advanced" curry implementation for multi-argument functions that we could use above.
 
 It's pretty short:
 
@@ -142,7 +147,7 @@ alert( curriedSum(1)(2)(3) ); // 6, full currying
 
 The new `curry` may look complicated, but it's actually easy to understand.
 
-The result of `curry(func)` is the wrapper `curried` that looks like this:
+The result of `curry(func)` call is the wrapper `curried` that looks like this:
 
 ```js
 // func is the function to transform
@@ -157,7 +162,7 @@ function curried(...args) {
 };
 ```
 
-When we run it, there are two execution branches:
+When we run it, there are two `if` execution branches:
 
 1. Call now: if passed `args` count is the same as the original function has in its definition (`func.length`) or longer, then just pass the call to it.
 2. Get a partial: otherwise, `func` is not called yet. Instead, another wrapper `pass` is returned, that will re-apply `curried` providing previous arguments together with the new ones. Then on a new call, again, we'll get either a new partial (if not enough arguments) or, finally, the result.
@@ -173,7 +178,9 @@ For the call `curried(1)(2)(3)`:
 If that's still not obvious, just trace the calls sequence in your mind or on the paper.
 
 ```smart header="Fixed-length functions only"
-The currying requires the function to have a known fixed number of arguments.
+The currying requires the function to have a fixed number of arguments.
+
+A function that uses rest parameters, such as `f(...args)`, can't be curried this way.
 ```
 
 ```smart header="A little more than currying"

2-ui/3-event-details/1-mouse-events-basics/01-selectable-list/task.md

@@ -14,4 +14,5 @@ The demo:
 [iframe border="1" src="solution" height=180]
 
 P.S. For this task we can assume that list items are text-only. No nested tags.
+
 P.P.S. Prevent the native browser selection of the text on clicks.

2-ui/3-event-details/1-mouse-events-basics/head.html

@@ -4,25 +4,28 @@
 
   function showmesg(t, form) {
 
-     if (timer==0) timer = new Date()
+     if (timer == 0) {
+       timer = new Date();
+     }
+
+     let tm = new Date();
 
-     let tm = new Date()
-     if (tm-timer > 300) {
-  	t = '------------------------------\n'+t
+     if (tm - timer > 300) {
+       t = '------------------------------\n' + t;
      }
 
-     let area = document.forms[form+'form'].getElementsByTagName('textarea')[0]
+     let area = document.forms[form + 'form'].getElementsByTagName('textarea')[0];
 
      area.value += t + '\n';
-     area.scrollTop = area.scrollHeight
+     area.scrollTop = area.scrollHeight;
 
-     timer = tm
+     timer = tm;
   }
 
   function logMouse(e) {
      let evt = e.type;
      while (evt.length < 11) evt += ' ';
-     showmesg(evt+" which="+e.which, 'test')
+     showmesg(evt + " which=" + e.which, 'test')
      return false;
   }
 

2-ui/3-event-details/3-mousemove-mouseover-mouseout-mouseenter-mouseleave/1-behavior-nested-tooltip/task.md

@@ -4,10 +4,12 @@ importance: 5
 
 # Improved tooltip behavior
 
-Write JavaScript that shows a tooltip over an element with the attribute `data-tooltip`.
+Write JavaScript that shows a tooltip over an element with the attribute `data-tooltip`. The value of this attribute should become the tooltip text.
 
 That's like the task <info:task/behavior-tooltip>, but here the annotated elements can be nested. The most deeply nested tooltip is shown.
 
+Only one tooltip may show up at the same time.
+
 For instance:
 
 ```html
@@ -21,5 +23,3 @@ For instance:
 The result in iframe:
 
 [iframe src="solution" height=300 border=1]
-
-P.S. Hint: only one tooltip may show up at the same time.