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

Author: iliakan

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

@@ -104,7 +104,7 @@ Here's a more complex example:
 alert(2 + 2 + '1' ); // "41" and not "221"
 ```
 
-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`.
+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'`.
 
 ```js run
 alert('1' + 2 + 2); // "122" and not "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,7 @@ A good page to see the current state of support for language features is <https:
 
 As programmers, we'd like to use most recent features. The more good stuff - the better!
 
-From the other hand, how to make out modern code work on older engines that don't understand recent features yet?
+On the other hand, how to make our modern code work on older engines that don't understand recent features yet?
 
 There are two tools for that:
 

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

@@ -438,7 +438,7 @@ This operator has no special treatment for arrays, it works with them as with an
 Let's recall the rules:
 
 - Two objects are equal `==` only if they're references to the same object.
-- If one of 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>.
+- 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.
 
 The strict comparison `===` is even simpler, as it doesn't convert types. 

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

@@ -51,7 +51,7 @@ user.sayHi();
 
 When `new User("John")` is called:
 1. A new object is created.
-2. The `constructor` runs with the given argument and assigns `this.name` to it.
+2. The `constructor` runs with the given argument and assigns it to `this.name`.
 
 ...Then we can call methods, such as `user.sayHi`.
 

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

@@ -55,7 +55,7 @@ rabbit.run(5); // White Rabbit runs with speed 5.
 rabbit.hide(); // White Rabbit hides!
 ```
 
-Object of `Rabbit` class have access to both `Rabbit` methods, such as `rabbit.hide()`, and also to `Animal` methods, such as `rabbit.run()`.
+Object of `Rabbit` class have access both to `Rabbit` methods, such as `rabbit.hide()`, and also to `Animal` methods, such as `rabbit.run()`.
 
 Internally, `extends` keyword works using the good old prototype mechanics. It sets `Rabbit.prototype.[[Prototype]]` to `Animal.prototype`. So, if a method is not found in `Rabbit.prototype`, JavaScript takes it from `Animal.prototype`.
 

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

@@ -70,7 +70,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: