Typos en version part ii translation jobs (#71)

moustaphaotf · web-flow · commit 6983ca40f10e · 2023-10-07T13:46:31.000-05:00
* Added an explanation block on the 3 options of the for loops + ortho

It may be intriguing to know how the 3 option may be given
I also corrected errors on sentences where I found necessary &amp; reformulated some others.

* Fixed, link to variable chapter &amp; typos &amp; paragraphs
diff --git a/en/SUMMARY.md b/en/SUMMARY.md
@@ -47,7 +47,7 @@
   - [Mutable](objects/mutable.md)
   - [Reference](objects/reference.md)
   - [Prototype](objects/prototype.md)
-  - [Delete](objects/delete.md)
+  - [Delete Operator](objects/delete.md)
   - [Enumeration](objects/enumeration.md)
 - [Date and Time](date-and-time.md)
 - [JSON](json.md)
diff --git a/en/exercises/console.md b/en/exercises/console.md
@@ -23,4 +23,4 @@ console.log(age);
 
 ### 💡 Hints:
 
-* Visit the [variabl](../basics/variables.md)[e](../basics/variables.md) chapter to understand more about variables.
+* Visit the [variable](../basics/variables.md) chapter to understand more about variables.
diff --git a/en/exercises/objects.md b/en/exercises/objects.md
@@ -8,7 +8,7 @@ Objects are the collection of `key`, `value` pairs and each pair of key-value ar
 
 ### 📝 Tasks:
 
-Given a Doe family that includes two-member, where each member's information is provided in form of an object.&#x20;
+Given a Doe family that includes two members, where each member's information is provided in form of an object.&#x20;
 
 ```javascript
 let person = {
@@ -37,7 +37,7 @@ let family = {
 
 * [ ] Find a way to print the name of the first member of the Doe family in a `console`.
 * [ ] Change the fourth  `luckyNumbers` of  the second member of the Doe family to `33`.
-* [ ] Add a new member to the family by creating a new  person  (`Jimmy,` `Doe`, `13`, `male`, `[1, 2, 3, 4]`, `null`) and update the member list.
+* [ ] Add a new member to the family by creating a new  person  (`Jimmy` `Doe`, `13`, `male`, `[1, 2, 3, 4]`, `null`) and update the member list.
 * [ ] Print the `SUM` of the lucky numbers of Doe family in the `console`.&#x20;
 
 ### 💡 Hints:
diff --git a/en/loops/README.md b/en/loops/README.md
@@ -8,7 +8,7 @@ description: Loops are control structures that allow you to execute a block of c
 # Chapter 7
 # Loops
 
-Loops are repetitive conditions where one variable in the loop changes. Loops are handy, if you want to run the same code over and over again, each time with a different value.
+Loops are repetitive instructions where one variable in the loop changes. Loops are handy, if you want to run the same code over and over again, each time with a different value.
 
 Instead of writing:
 
diff --git a/en/loops/dowhile.md b/en/loops/dowhile.md
@@ -1,11 +1,11 @@
 ---
 chapter: 7
 pageNumber: 52
-description: The do...while statement creates a loop that executes a specified statement until the test condition evaluates to be false. The condition is evaluated after executing the statement.
+description: The do...while statement creates a loop that executes specified bloc statement until the test condition evaluates to be false. The condition is evaluated after executing the block.
 ---
 # Do...While
 
-The do...while statement creates a loop that executes a specified statement until the test condition evaluates to be false. The condition is evaluated after executing the statement. The syntax for do... while is
+The do...while statement creates a loop that executes specified bloc statement until the test condition evaluates to be false. The condition is evaluated after executing the block. The syntax for do... while is
 
 ```javascript
 do {
diff --git a/en/loops/for.md b/en/loops/for.md
@@ -8,11 +8,16 @@ description:  A for loop is a powerful control structure used to execute a block
 The easiest form of a loop is the for statement. This one has a syntax that is similar to an if statement, but with more options:
 
 ```javascript
-for (condition; end condition; change) {
+for (initialization; end condition; change) {
     // do it, do it now
 }
 ```
 
+## Explanation:
+
+* In the `initialization` part, executed before the first iteration, initialize your loop variable
+* In the `end codition` part, put a condition that may be checked before each iteration. The moment the condition becomes `false`, the loop ends.
+* In the `change` part, tell the program how to update the loop variable.
 Let's see how to execute the same code ten-times using a `for` loop:
 
 ```javascript
@@ -57,6 +62,8 @@ The value of iterable objects such as `Arrays`, `Strings`, `Maps`, `NodeLists` c
 let language = "JavaScript";
 let text = "";
 for (let x of language) {
-text += x;
+  text += x;
 }
+
+// Result: language = 'JavaScript'
 ```
diff --git a/en/loops/while.md b/en/loops/while.md
@@ -17,7 +17,7 @@ For example, the loop in this example will repetitively execute its block of cod
 
 ```javascript
 var i = 0,
-  x = "";
+x = "";
 while (i < 5) {
   x = x + "The number is " + i;
   i++;
diff --git a/en/miscellaneous/building-and-deploying.md b/en/miscellaneous/building-and-deploying.md
@@ -9,7 +9,7 @@ Developing and deploying a JavaScript application involves a series of steps tha
 
 ## Setting up the Development Environment
 
-Before commencing the development process, it is essential for the developer to ensure that Node.js and npm (Node Package Manager) are installed on their system. These vital tools can be acquired from the official website of Node.js [Node.js](https://nodejs.org/). Additionally, the developer should select an appropriate code editor or Integrated Development Environment (IDE) for JavaScript development. Some of the popular choices include [Visual Studio Code](https://code.visualstudio.com/), [Sublime Text](https://code.visualstudio.com/), and [WebStorm](https://www.jetbrains.com/webstorm/).
+Before commencing the development process, it is essential for the developer to ensure that Node.js and npm (Node Package Manager) are installed on their system. These vital tools can be acquired from the official website of Node.js [Node.js](https://nodejs.org/). Additionally, the developer should select an appropriate code editor or Integrated Development Environment (IDE) for JavaScript development. Some of the popular choices include [Visual Studio Code](https://code.visualstudio.com/), [Sublime Text](https://www.sublimetext.com/), and [WebStorm](https://www.jetbrains.com/webstorm/).
 
 The installation of Node.js and npm provides access to the essential tools and libraries required for JavaScript development. The careful selection of the appropriate code editor or IDE can substantially enhance productivity and code quality.
 
diff --git a/en/miscellaneous/currying.md b/en/miscellaneous/currying.md
@@ -1,11 +1,12 @@
 ---
 chapter: 19
 pageNumber: 95
-description: Currying is an advanced technique in functional programming of transforming a function with multiple arguments into a sequence of nesting functions. It transforms a function from callable  f(a,b,c) into callable as f(a)(b)(c). It doesn’t call a function instead it transforms it.
+description: Currying is an advanced technique in functional programming that consists of transforming a function with multiple arguments into a sequence of nesting functions. It transforms a function from callable f(a,b,c) into callable as f(a)(b)(c). It doesn’t call a function instead it transforms it.
 ---
 # Currying
 
-`Currying` is an advanced technique in functional programming of transforming a function with multiple arguments into a sequence of nesting functions. It transforms a function from callable  `f(a,b,c)` into callable as `f(a)(b)(c)`. It doesn’t call a function instead it transforms it.
+`Currying` is an advanced technique in functional programming that consists of transforming a function with multiple arguments into a sequence of nesting functions. It transforms a function from callable `f(a,b,c)` into callable as `f(a)(b)(c)`. It doesn’t call a function instead it transforms it.
+
 
 To get a better understanding of currying let’s create a simple `add` function add that takes three arguments and returns the sum of them. Then, we create a `addCurry` function that takes a single input and returns a series of functions with its sum.
 
diff --git a/en/miscellaneous/polyfills-and-transpilers.md b/en/miscellaneous/polyfills-and-transpilers.md
@@ -48,7 +48,7 @@ Array.prototype.filter = function (callback) {
   const result = [];
   for (let i = 0; i < this.length; i++) {
     // call the callback with the current element, index, and context.
-    //if it passes the text then add the element in the new array.
+    //if it passes the test then add the element in the new array.
     if (callback(this[i], i, this)) {
       result.push(this[i]);
     }
diff --git a/en/objects/delete.md b/en/objects/delete.md
@@ -1,11 +1,11 @@
 ---
 chapter: 9
 pageNumber: 62
-description: A `delete` property can be used to **remove a property** from an object. When a property is deleted, it is removed from the object and cannot be accessed or enumerated (i.e., it does not show up in a for-in loop).
+description: The `delete` operator can be used to **remove a property** from an object. When a property is deleted, it is removed from the object and cannot be accessed or enumerated (i.e., it does not show up in a for-in loop).
 ---
-# Delete
+# Delete Operator
 
-A `delete` property can be used to **remove a property** from an object. When a property is deleted, it is removed from the object and cannot be accessed or enumerated (i.e., it does not show up in a for-in loop).
+The `delete` operator can be used to **remove a property** from an object. When a property is deleted, it is removed from the object and cannot be accessed or enumerated (i.e., it does not show up in a for-in loop).
 
 Here's the syntax for using `delete`:
 
diff --git a/en/objects/reference.md b/en/objects/reference.md
@@ -5,19 +5,19 @@ description: A reference to an object is a value that points to the memory locat
 ---
 # Reference
 
-Objects are **never copied**. They are passed around by reference. An object reference is a value that refers to an object. When you create an object using the `new` operator or object literal syntax, JavaScript creates an object and assigns a reference to it.
+Objects are **never copied**. They are passed around by reference. An object's reference is a value that refers to an object. When you create an object using the `new` operator or object literal syntax, JavaScript creates an object and assigns a reference to it.
 
 Here's an example of creating an object using the object literal syntax:
 
-```css
+```javascript
 var object = {
   foo: 'bar'
 };
 ```
 
 Here's an example of creating an object using the `new` operator:
 
-```typescript
+```javascript
 var object = new Object();
 object.foo = 'bar';
 ```
@@ -42,7 +42,7 @@ In the example above, both `object1` and `object2` are variables that hold refer
 You can use the `Object.assign()` method to create a new object that is a copy of an existing object.&#x20;
 {% endhint %}
 
-Following is an example of an object by reference.
+Following is an example of creating an object by reference.
 
 ```javascript
 // Imagine I had a pizza
diff --git a/en/promise-async-await/README.md b/en/promise-async-await/README.md
@@ -2,8 +2,10 @@
 layout: editorial
 chapter: 17
 pageNumber: 87
+description: Promises are now used by most modern APIs. It is therefore important to understand how they work and to know how to use them to optimize your code.
 ---
 
 # Chapter 18
 # Promise, async/await
 
+Promises are now used by most modern APIs. It is therefore important to understand how they work and to know how to use them to optimize your code. In this chapter, we'll define in detail what promises are and how to use them in asynchronous operations.
diff --git a/en/promise-async-await/promise.md b/en/promise-async-await/promise.md
@@ -23,7 +23,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-Here, a function is passed to `new Promise` also known as the _executor_, and runs automatically upon creation. It contains the producing code that gives the result. `resolve` and `rejects` are the arguments provided by the JavaScript itself and are called one of these upon results.
+Here, a function is passed to `new Promise` also known as the _executor_, and runs automatically upon creation. It contains the producing code that gives the result. `resolve` and `reject` are the arguments provided by the JavaScript itself and are called one of these upon results.
 
 * `resolve(value):` a callback function that returns `value` upon result
 * `reject(error)`: a callback function that returns `error` upon error, it returns an error object
@@ -32,8 +32,8 @@ Here, a function is passed to `new Promise` also known as the _executor_, and ru
 
 The internal properties of `promise` object returned by the `new Promise` constructor are as follows:
 
-* `state` - initially `pending,` then changes to either `fulfill` upon resolve or `rejected` when `reject` is called
-* result - initially `undefined`, then changes to `value` upon `resolve` or `error` when `reject` is called
+* `state` - initially `pending,` then changes to either `fulfill` upon `resolve` or `rejected` when `reject` is called
+* `result` - initially `undefined`, then changes to `value` upon `resolve` or `error` when `reject` is called
 
 {% hint style="warning" %}
 One cannot access promise properties: `state` and `result`. Promise methods are needed to handle promises.
@@ -57,7 +57,7 @@ let promiseTwo = new Promise(function(resolve, reject) {
 })
 ```
 
-Here, the `promiseOne` is an example of a "_fulfilled promise_" as it successfully resolves the values, whereas the `promiseTwo` is a "_rejected promise_" as it gets rejected. A promise that is either rejected or resolved is called a _settled_ promise, as opposed to an initially _pending_ promise. Consuming function from the promise can be registered using the `.then` and `.catch` methods. We can also add `.finally` method for performing cleanup or finalizing after previous methods have been completed.
+Here, the `promiseOne` is an example of a "_fulfilled promise_" as it successfully resolves the values, whereas the `promiseTwo` is a "_rejected promise_" as it gets rejected. A promise that is neither rejected or resolved is called a _settled_ promise, as opposed to an initially _pending_ promise. Consuming function from the promise can be registered using the `.then` and `.catch` methods. We can also add `.finally` method for performing cleanup or finalizing after previous methods have been completed.
 
 ```javascript
 let promiseOne = new Promise(function(resolve, reject) {

Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,4 @@ console.log(age);`
`23`	`23`
`24`	`24`	`### 💡 Hints:`
`25`	`25`
`26`		`-* Visit the [variabl](../basics/variables.md)[e](../basics/variables.md) chapter to understand more about variables.`
	`26`	`+* Visit the [variable](../basics/variables.md) chapter to understand more about variables.`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ Array.prototype.filter = function (callback) {`
`48`	`48`	`const result = [];`
`49`	`49`	`for (let i = 0; i < this.length; i++) {`
`50`	`50`	`// call the callback with the current element, index, and context.`
`51`		`- //if it passes the text then add the element in the new array.`
	`51`	`+ //if it passes the test then add the element in the new array.`
`52`	`52`	`if (callback(this[i], i, this)) {`
`53`	`53`	`result.push(this[i]);`
`54`	`54`	`}`