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

# Conflicts:
#	1-js/01-getting-started/2-manuals-specifications/article.md
#	1-js/02-first-steps/04-variables/article.md
#	1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
#	1-js/02-first-steps/06-type-conversions/article.md
#	1-js/02-first-steps/07-operators/article.md
#	1-js/02-first-steps/16-javascript-specials/article.md
#	1-js/03-code-quality/06-polyfills/article.md
#	1-js/06-advanced-functions/03-closure/article.md
#	1-js/11-async/02-promise-basics/article.md
#	5-network/05-fetch-crossorigin/1-do-we-need-origin/task.md

Author: mehradsadeghi

1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md

@@ -14,11 +14,11 @@ true + false = 1
 " -9  " - 5 = -14 // (4)
 null + 1 = 1 // (5)
 undefined + 1 = NaN // (6)
+" \t \n" - 2 = -2 // (7)
 ```
 1. علامت جمع همراه با string `"" + 1` عدد `1` را به string تبدیل می‌کند: `"" + 1 = "1"` ، و سپس داریم: `"1" + 0` که همین قاعده برای آن نیز برقرار خواهد بود.
 2. علامت تفریق (مانند اکثر عملگرهای ریاضیاتی) فقط با اعداد کار می‌کند. این عملگر string خالی را به `0` تبدیل می‌کند.
 3. علامت جمع به همراه string ، باعث تبدیل عدد `5` به string و سپس چسباندن آن بهم می‌شود.
 4. علامت تفریق همیشه مقدار را به عدد تبدیل می‌کند. در نتیجه `"  -9  "` را به عدد `–9` تبدیل می‌کند (فاصله‌های خالی را نیز حذف می‌کند).
 5. `null` پس از تبدیل به عدد `0` خواهد بود.
-6. `undefined` پس از تبدیل به عدد `NaN` خواهد بود.
-
+6. `undefined` پس از تبدیل به عدد `NaN` خواهد بود.

1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md

@@ -21,6 +21,7 @@ true + false
 "  -9  " - 5
 null + 1
 undefined + 1
+" \t \n" - 2
 ```
 
 به خوبی روی آن فکر کنید، بنویسید و با پاسخ‌ها مقایسه کنید.

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

@@ -108,8 +108,8 @@ Let's examine the `for` statement part-by-part:
 |-------|----------|----------------------------------------------------------------------------|
 | begin | `i = 0`    | Executes once upon entering the loop.                                      |
 | condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
-| step| `i++`      | Executes after the body on each iteration but before the condition check. |
 | body | `alert(i)`| Runs again and again while the condition is truthy.                         |
+| step| `i++`      | Executes after the body on each iteration. |
 
 The general loop algorithm works like this:
 
@@ -300,7 +300,7 @@ This is just another reason not to use the question mark operator `?` instead of
 
 Sometimes we need to break out from multiple nested loops at once.
 
-For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(3,3)`:
+For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(2,2)`:
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {

1-js/03-code-quality/03-comments/article.md

@@ -175,6 +175,6 @@ Good comments allow us to maintain the code well, come back to it after a delay
 **Avoid comments:**
 
 - That tell "how code works" and "what it does".
-- Put them only if it's impossible to make the code so simple and self-descriptive that it doesn't require those.
+- Put them in only if it's impossible to make the code so simple and self-descriptive that it doesn't require them.
 
 Comments are also used for auto-documenting tools like JSDoc3: they read them and generate HTML-docs (or docs in another format).

1-js/03-code-quality/06-polyfills/article.md

@@ -19,21 +19,20 @@ Here Babel comes to the rescue.
 
 Actually, there are two parts in Babel:
 
-1. First, the transpiler program, which rewrites the code. The developer runs it on their own computer. It rewrites the code into the older standard. And then the code is delivered to the website for users. Modern project build system like [webpack](http://webpack.github.io/) or [brunch](http://brunch.io/) provide means to run transpiler automatically on every code change, so that doesn't involve any time loss from our side.
+1. First, the transpiler program, which rewrites the code. The developer runs it on their own computer. It rewrites the code into the older standard. And then the code is delivered to the website for users. Modern project build systems like [webpack](http://webpack.github.io/) provide means to run transpiler automatically on every code change, so that very easy to integrate into development process.
 
 2. Second, the polyfill.
 
-    The transpiler rewrites the code, so syntax features are covered. But for new functions we need to write a special script that implements them. JavaScript is a highly dynamic language, scripts may not just add new functions, but also modify built-in ones, so that they behave according to the modern standard.
+    New language features may include new built-in functions and syntax constructs.
+    The transpiler rewrites the code, transforming syntax constructs into older ones. But as for new built-in functions, we need to implement them. JavaScript is a highly dynamic language, scripts may add/modify any functions, so that they behave according to the modern standard.
 
-    There's a term "polyfill" for scripts that "fill in" the gap and add missing implementations.
+    A script that updates/adds new functions is called "polyfill". It "fills in" the gap and adds missing implementations.
 
     Two interesting polyfills are:
     - [core js](https://github.com/zloirock/core-js) that supports a lot, allows to include only needed features.
     - [polyfill.io](http://polyfill.io) service that provides a script with polyfills, depending on the features and user's browser.
 
-So, we need to setup the transpiler and add the polyfill for old engines to support modern features.
-
-If we orient towards modern engines and do not use features except those supported everywhere, then we don't need to use Babel.
+So, if we're going to use modern language features, a transpiler and a polyfill are necessary.
 
 ## Examples in the tutorial
 
@@ -49,9 +48,7 @@ Examples that use modern JS will work only if your browser supports it.
 ````
 
 ```offline
-As you're reading the offline version, examples are not runnable. But they usually work :)
+As you're reading the offline version, in PDF examples are not runnable. In EPUB some of them can run.
 ```
 
-[Chrome Canary](https://www.google.com/chrome/browser/canary.html) is good for all examples, but other modern browsers are mostly fine too.
-
-Note that on production we can use Babel to translate the code into suitable for less recent browsers, so there will be no such limitation, the code will run everywhere.
+Google Chrome is usually the most up-to-date with language features, good to run bleeding-edge demos without any transpilers, but other modern browsers also work fine.

1-js/04-object-basics/01-object/variable-copy-value.svg

@@ -27,7 +27,7 @@ alert(user.name); // Jack
 alert(user.isAdmin); // false
 ```
 
-When a function is executed as `new User(...)`, it does the following steps:
+When a function is executed with `new`, it does the following steps:
 
 1. A new empty object is created and assigned to `this`.
 2. The function body executes. Usually it modifies `this`, adds new properties to it.
@@ -51,7 +51,7 @@ function User(name) {
 }
 ```
 
-So the result of `new User("Jack")` is the same object as:
+So `let user = new User("Jack")` gives the same result as:
 
 ```js
 let user = {
@@ -146,10 +146,10 @@ function BigUser() {
 
   this.name = "John";
 
-  return { name: "Godzilla" };  // <-- returns an object
+  return { name: "Godzilla" };  // <-- returns this object
 }
 
-alert( new BigUser().name );  // Godzilla, got that object ^^
+alert( new BigUser().name );  // Godzilla, got that object
 ```
 
 And here's an example with an empty `return` (or we could place a primitive after it, doesn't matter):
@@ -159,10 +159,7 @@ function SmallUser() {
 
   this.name = "John";
 
-  return; // finishes the execution, returns this
-
-  // ...
-
+  return; // <-- returns this
 }
 
 alert( new SmallUser().name );  // John

1-js/04-object-basics/06-constructor-new/article.md

@@ -1,6 +1,6 @@
 function Calculator() {
 
-  let methods = {
+  this.methods = {
     "-": (a, b) => a - b,
     "+": (a, b) => a + b
   };
@@ -12,14 +12,14 @@ function Calculator() {
       op = split[1],
       b = +split[2]
 
-    if (!methods[op] || isNaN(a) || isNaN(b)) {
+    if (!this.methods[op] || isNaN(a) || isNaN(b)) {
       return NaN;
     }
 
-    return methods[op](a, b);
+    return this.methods[op](a, b);
   }
 
   this.addMethod = function(name, func) {
-    methods[name] = func;
+    this.methods[name] = func;
   };
 }

1-js/05-data-types/05-array-methods/6-calculator-extendable/_js.view/solution.js

@@ -1,3 +1,5 @@
 
-- Please note how methods are stored. They are simply added to the internal object.
+- Please note how methods are stored. They are simply added to `this.methods` property.
 - All tests and numeric conversions are done in the `calculate` method. In future it may be extended to support more complex expressions.
+
+[js src="_js/solution.js"]

1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md

@@ -31,6 +31,6 @@ The task consists of two parts.
     alert( result ); // 8
     ```
 
-- No brackets or complex expressions in this task.
+- No parentheses or complex expressions in this task.
 - The numbers and the operator are delimited with exactly one space.
 - There may be error handling if you'd like to add it.