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

� Conflicts:
�	1-js/02-first-steps/02-structure/article.md
�	1-js/02-first-steps/07-operators/article.md

Author: mehradsadeghi

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

@@ -301,11 +301,11 @@ As for now, it's important to know that such behavior of `__proto__` can become
 
 The problem is that a visitor may choose `__proto__` as the key, and the assignment logic will be ruined (as shown above).
 
-Later we'll see workarounds for the problem:
-1. We'll see how to make an objects treat `__proto__` as a regular property in the chapter [](info:prototype-methods).
-2. There's also study another data structure [Map](info:map-set) in the chapter <info:map-set>, which supports arbitrary keys.
+There are two workarounds for the problem:
+1. Modify the object's behavior to treat `__proto__` as a regular property. We'll learn how to do it in the chapter [](info:prototype-methods).
+2. Using [Map](info:map-set) data structure which supports arbitrary keys. We'll learn it in the chapter <info:map-set>.
 
-## Property existance test, "in" operator
+## Property existence test, "in" operator
 
 A notable objects feature is that it's possible to access any property. There will be no error if the property doesn't exist! Accessing a non-existing property just returns `undefined`. It provides a very common way to test whether the property exists -- to get it and compare vs undefined:
 

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

@@ -63,7 +63,7 @@ user.sayHi(); // Hello!
 ```smart header="Object-oriented programming"
 When we write our code using objects to represent entities, that's called [object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming), in short: "OOP".
 
-OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture, and there are great books on that topic, like "Design Patterns: Elements of Reusable Object-Oriented Software" by E.Gamma, R.Helm, R.Johnson, J.Vissides or "Object-Oriented Analysis and Design with Applications" by G.Booch, and more.
+OOP is a big thing, an interesting science of its own. How to choose the right entities? How to organize the interaction between them? That's architecture, and there are great books on that topic, like "Design Patterns: Elements of Reusable Object-Oriented Software" by E. Gamma, R. Helm, R. Johnson, J. Vissides or "Object-Oriented Analysis and Design with Applications" by G. Booch, and more.
 ```
 ### Method shorthand
 

1-js/05-data-types/04-array/10-maximal-subarray/task.md

@@ -10,15 +10,15 @@ The task is: find the contiguous subarray of `arr` with the maximal sum of items
 
 Write the function `getMaxSubSum(arr)` that will return that sum.
 
-For instance: 
+For instance:
 
 ```js
-getMaxSubSum([-1, *!*2, 3*/!*, -9]) = 5 (the sum of highlighted items)
-getMaxSubSum([*!*2, -1, 2, 3*/!*, -9]) = 6
-getMaxSubSum([-1, 2, 3, -9, *!*11*/!*]) = 11
-getMaxSubSum([-2, -1, *!*1, 2*/!*]) = 3
-getMaxSubSum([*!*100*/!*, -9, 2, -3, 5]) = 100
-getMaxSubSum([*!*1, 2, 3*/!*]) = 6 (take all)
+getMaxSubSum([-1, *!*2, 3*/!*, -9]) == 5 (the sum of highlighted items)
+getMaxSubSum([*!*2, -1, 2, 3*/!*, -9]) == 6
+getMaxSubSum([-1, 2, 3, -9, *!*11*/!*]) == 11
+getMaxSubSum([-2, -1, *!*1, 2*/!*]) == 3
+getMaxSubSum([*!*100*/!*, -9, 2, -3, 5]) == 100
+getMaxSubSum([*!*1, 2, 3*/!*]) == 6 (take all)
 ```
 
 If all items are negative, it means that we take none (the subarray is empty), so the sum is zero:

1-js/05-data-types/05-array-methods/12-reduce-object/task.md

@@ -20,7 +20,7 @@ let users = [
 let usersById = groupById(users);
 
 /*
-// after the call we have:
+// after the call we should have:
 
 usersById = {
   john: {id: 'john', name: "John Smith", age: 20}

1-js/06-advanced-functions/01-recursion/article.md

@@ -302,7 +302,7 @@ let company = {
     salary: 1000
   }, {
     name: 'Alice',
-    salary: 600
+    salary: 1600
   }],
 
   development: {
@@ -350,7 +350,7 @@ The algorithm is probably even easier to read from the code:
 
 ```js run
 let company = { // the same object, compressed for brevity
-  sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 600 }],
+  sales: [{name: 'John', salary: 1000}, {name: 'Alice', salary: 1600 }],
   development: {
     sites: [{name: 'Peter', salary: 2000}, {name: 'Alex', salary: 1800 }],
     internals: [{name: 'Jack', salary: 1300}]
@@ -372,7 +372,7 @@ function sumSalaries(department) {
 }
 */!*
 
-alert(sumSalaries(company)); // 6700
+alert(sumSalaries(company)); // 7700
 ```
 
 The code is short and easy to understand (hopefully?). That's the power of recursion. It also works for any level of subdepartment nesting.

1-js/06-advanced-functions/03-closure/article.md

@@ -345,7 +345,7 @@ let arr = [f(), f(), f()];
 
 A Lexical Environment object dies when it becomes unreachable (just like any other object). In other words, it exists only while there's at least one nested function referencing it.
 
-In the code below, after the nested function is removed, its enclosing Lexical Environment (and hence the `value`) is cleaned from memory;
+In the code below, after the nested function is removed, its enclosing Lexical Environment (and hence the `value`) is cleaned from memory:
 
 ```js
 function f() {

1-js/06-advanced-functions/04-var/article.md

@@ -138,7 +138,7 @@ So in the example above, `if (false)` branch never executes, but that doesn't ma
 
 **Declarations are hoisted, but assignments are not.**
 
-That's better to demonstrate with an example, like this:
+That's best demonstrated with an example:
 
 ```js run
 function sayHi() {

1-js/11-async/06-promisify/article.md

@@ -51,7 +51,7 @@ function promisify(f) {
     return new Promise((resolve, reject) => {
       function callback(err, result) { // our custom callback for f
         if (err) {
-          return reject(err);
+          reject(err);
         } else {
           resolve(result);
         }
@@ -82,7 +82,7 @@ function promisify(f, manyArgs = false) {
     return new Promise((resolve, reject) => {
       function *!*callback(err, ...results*/!*) { // our custom callback for f
         if (err) {
-          return reject(err);
+          reject(err);
         } else {
           // resolve with all callback results if manyArgs is specified
           *!*resolve(manyArgs ? results : results[0]);*/!*

1-js/99-js-misc/01-proxy/article.md

@@ -4,6 +4,8 @@ A `Proxy` object wraps another object and intercepts operations, like reading/wr
 
 Proxies are used in many libraries and some browser frameworks. We'll see many practical applications in this article.
 
+## Proxy
+
 The syntax:
 
 ```js

5-network/01-fetch/article.md

@@ -1,7 +1,7 @@
 
 # Fetch
 
-JavaScript can send network requests to the server and load new information whenever is needed.
+JavaScript can send network requests to the server and load new information whenever it's needed.
 
 For example, we can use a network request to:
 
@@ -66,7 +66,7 @@ if (response.ok) { // if HTTP-status is 200-299
 - **`response.formData()`** -- return the response as `FormData` object (explained in the [next chapter](info:formdata)),
 - **`response.blob()`** -- return the response as [Blob](info:blob) (binary data with type),
 - **`response.arrayBuffer()`** -- return the response as [ArrayBuffer](info:arraybuffer-binary-arrays) (low-level representaion of binary data),
-- additionally, `response.body` is a [ReadableStream](https://streams.spec.whatwg.org/#rs-class) object, it allows to read the body chunk-by-chunk, we'll see an example later.
+- additionally, `response.body` is a [ReadableStream](https://streams.spec.whatwg.org/#rs-class) object, it allows you to read the body chunk-by-chunk, we'll see an example later.
 
 For instance, let's get a JSON-object with latest commits from GitHub:
 
@@ -230,7 +230,7 @@ But, as we're going to send JSON, we use `headers` option to send `application/j
 
 We can also submit binary data with `fetch` using `Blob` or `BufferSource` objects.
 
-In this example, there's a `<canvas>` where we can draw by moving a mouse over it. A click on the "submit" button sends the image to server:
+In this example, there's a `<canvas>` where we can draw by moving a mouse over it. A click on the "submit" button sends the image to the server:
 
 ```html run autorun height="90"
 <body style="margin:0">