typos fixed

Author: Hamidalavi

Learn/3. Control Structures (condition, loop and etc.).md

@@ -11,16 +11,16 @@ In this course, you will learn about:
 
 |Operator|Description|Example|
 |:-:|:-:|:-:|
-|`==`|Check for value equality|`a == b`|
-|`!=`|Check for value inequality|`a != b`|
-|`===` and `!==`|Check for value **and** type (in)equality|`a === b` / `a !== b`|
-|`>` and `<`|Check for value being greater / smaller|`a > b` / `a < b`|
-|`>=` and `<=`|Check for value being greater or equal / smaller or equal|`a >= b` / `a <= b`|
-|`!`|Check if **note** true|`!a`|
+|`==`|Checks value equality|`a == b`|
+|`!=`|Checks value inequality|`a != b`|
+|`===` and `!==`|Checks value **and** type (in)equality|`a === b` / `a !== b`|
+|`>` and `<`|Checks value being greater / smaller|`a > b` / `a < b`|
+|`>=` and `<=`|Checks value being greater or equal / smaller or equal|`a >= b` / `a <= b`|
+|`!`|Checks if value is **not** true|`!a`|
 
 One of most using statement for conditions, is `if` statement. Always keep in mind that condition in `if (condition) { .. }` simply has to be a **boolean value**.
 
-Often, you'll **generate** such a boolean value with the help of `===,` `>`, `<` etc. **All these operators yield boolean values** (without changing the variables / values you're using them on).
+Often, you'll **generate** such a boolean value with the help of `===`, `>`, `<` and etc. **All these operators yield boolean values** (without changing the variables / values you're using them on).
 
 Since `if` only wants a boolean, you of course don't have to use such an operator. If you already got a variable that holds a boolean, you can use it without any extra operator. For example:
 
@@ -47,9 +47,9 @@ You can use the `!` operator to negate (**invert**) the value:
 ```js
 const isTrue = true;
 if (!isTrue) {
-    // This code will NOT execute because isTrue is true but ! inverts it (in this check)
+    // This code will NOT execute because `isTrue` is true but `!` inverts it (in this check)
 } else {
-    // This would execute because !isTrue yields false => else block executes
+    // This would execute because `!isTrue` yields false => else block executes
 }
 ```
 
@@ -78,11 +78,11 @@ console.log('a' > 'B'); // true
 console.log('a' > 'b'); // false
 ```
 
-For more information of operator precedence, see this [link](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence).
+For more information of operator precedence, see [this](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) link.
 
 ## Object Conditions
 
-`object`s and `array`s are special. For example:
+Objects and arrays are special. For example:
 
 ```js
 let obj1 = {name: "Hamid"};
@@ -108,7 +108,7 @@ console.log(obj1.name != obj2.name); // false
 console.log(obj1.name !== obj2.name); // false
 ```
 
-These are some reason that they are (objects) special. These also come true with `array`s. For example:
+These are some reason that objects are special. These also come true with arrays. For example:
 
 ```js
 let array1 = [1, 2, 3];
@@ -136,7 +136,7 @@ console.log(array1[0] !== array2[0]); // false
 
 ## `if` Statement
 
-What is `if`? `if` is a statement. We can use `if` for create some conditions for our code. For example, we want tell `"Stop!"` when number reach `10`:
+What is `if`? `if` is a statement. We can use `if` for create some conditions for our code. For example, we want tell `"Stop!"` when number reaches `10`:
 
 ```js
 let number = 0;
@@ -150,7 +150,7 @@ while(true){
 }
 ```
 
-In above snippet, we wanted if `number` more than or equal to `10`, execution will stop. `while` is a **loop** and cover it in later... while loop is `true` (iterate for ever), number will increase by `1`. After number reach `10`, execution will stop by `if` condition.
+In snippet above, we wanted if `number` more than or equal to `10`, execution then stop. `while` is a **loop** and we cover it in later. while loop is `true` (iterate for ever), number then increases by `1`. After number reaches `10`, execution will stop by `if` condition.
 
 We also have optional statement called `else`. If `if` condition not reach, `else` block will execute. For example:
 
@@ -164,15 +164,15 @@ if (name === "Hamid") {
 }
 ```
 
-In above snippet, if `name` equal to `"Hamid"`, output will `"True!"`, else if `name` not equal to `"Hamid"`, output will `"False"`. We called this `if..else` condition (statement).
+In snippet above, if `name` equal to `"Hamid"`, output will be `"True!"`, else if `name` not equal to `"Hamid"`, output will be `"False"`. We called this `if..else` condition (statement).
 
 ## Truethy and Falsy
 
 Some values are called **falsy**, like `0`, `0n`, `-0`, `null`, `undefined`, `false`, `NaN` and empty string `""`.
 
 Some values are called **truthy**, like `23`, `"hi"`, `true`, `[]`, `{}`, `object = {a:1}`, `function hamid() {..}` and `[23, 24]`.
 
-See below snippets:
+See these following snippets:
 
 ```js
 let name = "Hamid";
@@ -199,12 +199,12 @@ if (isTrue) {
 
 Since if just wants a condition that returns `true` or `false`, it makes sense that you can just provide a **boolean** variable or value and it works - without the extra comparison (`if (isTrue === true`) - that would also work but is redundant).
 
-Whilst the above example makes sense, it can be confusing when you encounter code like this for the first time:
+Whilst the example above makes sense, it can be confusing when you encounter code like this for the first time:
 
 ```js
 let userInput = 'Hamid';
 if (userInput) {
-    // this code here will execute because 'Hamid' is "truthy" (all strings but empty strings are)
+    // this code here will execute because 'Hamid' is "truthy" (all strings but empty strings are falsy)
 }
 ```
 
@@ -220,7 +220,7 @@ if (userInput) { ... }
 
 ## Ternary Operator
 
-We can use shorthand `? :` operator for `if` statements. For example, we can write code like below:
+We can use shorthand `? :` operator for `if` statements. For example, we can write code like:
 
 ```js
 const name = if (isTrue) {
@@ -236,7 +236,7 @@ But with ternary operator, we can do this:
 const name = isTrue ? "Hamid" : null;
 ```
 
-How above snippet work? It's very simple. First, we declare a constant that called `name`. Then, we check if `isTrue` is `true`, `"Hamid"` will execute, else the condition returns `null`.
+How this snippet work? It's very simple. First, we declared a constant that called `name`. Then, we checked if `isTrue` is `true`, `"Hamid"` will be executed, else the condition returns `null`.
 
 **Note**: `if` is statement, but **not expression**. Because it **can't** be after right-hand-side of a variable or a constant (after `=` assignment). But we can use **Ternary Operator** for this purpose. For example:
 
@@ -270,7 +270,7 @@ We can use `||` (or) operator for variable's value. For example:
 let firstName = "" || "Hamid";
 console.log(firstName); // "Hamid"
 
-let lastName = "Alavi" || "Willson"
+let lastName = "Alavi" || "Goertzel"
 console.log(lastName); // "Alavi"
 ```
 
@@ -292,7 +292,7 @@ And for better understanding with example, consider this table:
 |Value 1|Value 2|Value 3|Output|
 |:-:|:-:|:-:|:-:|
 |`false`|`false`|`true`|`true`|
-|`""`|`"Hamed"`|`"Ali"`|`"Ali"`|
+|`""`|`"Hamed"`|`"Ali"`|`"Hamed"`|
 |`false`|`NaN`|`"Hamid"`|`"Hamid"`|
 |`true`|`"Reza"`|`"Mehrdad"`|`true`|
 
@@ -304,8 +304,8 @@ We can use `&&` (and) operator for variable's value. For example:
 let firstName = "" && "Hamid";
 console.log(firstName); // ""
 
-let lastName = "Alavi" && "Willson"
-console.log(lastName); // "Willson"
+let lastName = "Alavi" && "Goertzel";
+console.log(lastName); // "Goertzel"
 ```
 
 In `firstName`, output is `""`, because first value is **falsy**.
@@ -338,7 +338,7 @@ And for better understanding with example, consider this table:
 let day = 4;
 
 if (day === 1) {
-  console.log("Monday");
+  console.log("Monday"); // this line executed
 } else if (day === 2) {
   console.log("Tuesday");
 } else if (day === 3) {
@@ -356,7 +356,7 @@ if (day === 1) {
 }
 ```
 
-See? If we want use complex conditiion, multiple combined conditions or greater than checks and so on. We definitely want to use `if/else` blocks and statements instead of the `switch-case` statement; because that really only shines for **strict equality** checks.
+See? If we want touse complex condition, multiple combined conditions or greater than checks and so on, we definitely want to use `if/else` blocks and statements instead of the `switch-case` statement; because that really only shines for **strict equality** checks.
 
 Let's look `switch-case` example:
 
@@ -374,7 +374,7 @@ switch (day) {
     console.log("Wednesday");
     break;
   case 4:
-    console.log("Thursday");
+    console.log("Thursday"); // this line executed
     break;
   case 5:
     console.log("Friday");
@@ -392,7 +392,7 @@ switch (day) {
 
 It's very easy to understand. We just pass the variable into the `()`. It means that our target is `day`. We can choose or add many conditions for that variable with `case` keyword. For example, if `day` is `4`, output will be `"Thursday"`. After each `case`, we use `break` keyword, because `break` keyword will stop rest execution after executes the matched condition.
 
-**Note**: The colon (`:`) after case, is exactly like `{ .. }` for `if..else` statement .
+**Note**: The `:` colon after `case`, is exactly like `{ .. }` for `if..else` statement .
 
 For more information, go to [this](https://stackoverflow.com/questions/32576618/switch-statement-to-compare-values-greater-or-less-than-a-number/32576647) link.
 
@@ -433,9 +433,9 @@ for (;;) {
 }
 ```
 
-It looks like a infinite loop (with no conditions).
+It looks like a infinite loop (without conditions).
 
-We also have a strage type of this loop, but we don't recommend you to this:
+We also have a strage type of this loop, but we don't recommend you to do this:
 
 ```js
 for (let i = 0; i < 10; i -= -1) {
@@ -526,11 +526,11 @@ See better visual output:
 ```js
 let object = { name: "Hamid", age: 23 };
 for (let key in object) {
-  console.log(`${key} => ${object[key]}`); // "Hamid" "23"
+  console.log(`${key} => ${object[key]}`);
 }
 /* "name => Hamid"
    "age => 23"
- */
+*/
 ```
 
 > `while` loop:
@@ -541,7 +541,7 @@ This loop executes code as long as a condition is true. For example:
 let i = 0;
 while (true) {
   console.log(i);
-  i++; // --infinite loop
+  i++; // infinite loop
 }
 ```
 
@@ -567,7 +567,7 @@ do {
 
 That means: **do** something, **while** that condition is `true` (or reach).
 
-**Note**: In `do..while` loops, we (you) need put semicolon (`;`) after `while` loop. Consider:
+**Note**: In `do..while` loops, we (you) need put `;` semicolon after `while` loop. Consider:
 
 ```js
 do {
@@ -577,7 +577,7 @@ do {
 
 ## `break` and `continue` Keywords
 
-**JavaScript** (and other programming languages) have two important keyword.
+**JavaScript** (and other programming languages) have two important keywords.
 
 > `break`
 
@@ -624,7 +624,7 @@ whileLoop: do {
 } while (number < 10);
 ```
 
-We defined `whileLoop` label (you can choose another name for it), and we created an `if` statement (condition) to stop executing code after `number` equal to `4`. This technique rarely use in **JavaScript**.
+We defined `whileLoop` label (you can choose whatever you want for it), and we created an `if` statement (condition) to stop executing code after `number` equal to `4`. This technique rarely use in **JavaScript**.
 
 ## Nested Loops and Conditions
 
@@ -785,7 +785,7 @@ function getMaxLifeValue() {
 
   // check for invalid entered number
   if (isNaN(parsedValue) || parsedValue <= 0) {
-    throw "Invalid user input, nnot a number!";
+    throw "Invalid user input, not a number!";
   }
   return parsedValue;
 }
@@ -797,7 +797,7 @@ try {
 } catch (error) {
   console.log(error);
   maxLife = 100;
-  alert("You enterd something wrong, deafult value of 100 was used.");
+  alert("You entered something wrong, deafult value of 100 was used.");
 }
 ```
 

practice.js

@@ -5607,5 +5607,8 @@ __proto__: WeakSet
 //   }
 // }
 
-const obj = {name: "hamid", age: 23, age: 25};
-console.log(obj)
+for (let i = 0; i < 10; i++) {
+  for (let j = 1; j < 10; j++) {
+    console.log(`i: ${i}`, `j: ${j}`);
+  }
+}