Merge pull request #137 from jmbothe/master

grammar, usage, punctuation edits, Part 1, sections 2.9 - 2.16

Author: iliakan

1-js/02-first-steps/09-alert-prompt-confirm/article.md

@@ -2,7 +2,7 @@
 
 This part of the tutorial aims to cover JavaScript "as is", without environment-specific tweaks.
 
-But still we use a browser as the demo environment. So we should know at least few user-interface functions. In this chapter we'll get familiar with the browser functions `alert`, `prompt` and `confirm`.
+But still we use a browser as the demo environment. So we should know at least a few user-interface functions. In this chapter we'll get familiar with the browser functions `alert`, `prompt` and `confirm`.
 
 [cut]
 
@@ -40,7 +40,7 @@ It shows a modal window with a text message, an input field for the visitor and
 `default`
 : An optional second parameter, the initial value for the input field.
 
-The visitor may type something in the prompt input field and press OK. Or they can cancel the input by pressing a CANCEL button or hitting the `key:Esc` key.
+The visitor may type something in the prompt input field and press OK. Or they can cancel the input by pressing the CANCEL button or hitting the `key:Esc` key.
 
 The call to `prompt` returns the text from the field or `null` if the input was canceled.
 

1-js/02-first-steps/10-ifelse/article.md

@@ -2,13 +2,13 @@
 
 Sometimes we need to perform different actions based on a condition.
 
-There is `if` statement for that and also the conditional (ternary) operator for conditional evaluation which we will be referring as  “question mark” operator: `"?"` for simplicity.
+There is the `if` statement for that and also the conditional (ternary) operator for conditional evaluation which we will be referring as  the “question mark” operator: `"?"` for simplicity.
 
 [cut]
 
 ## The "if" statement
 
-The "if" statement gets a condition, evaluates it and -- if the result is `true` -- executes the code.
+The "if" statement gets a condition, evaluates it and, if the result is `true`, executes the code.
 
 For example:
 
@@ -22,7 +22,7 @@ if (year == 2015) alert( 'You are right!' );
 
 In the example above, the condition is a simple equality check: `year == 2015`, but it can be much more complex.
 
-If there is more than one command to execute -- we can use a code block in figure brackets:
+If there is more than one command to execute, we can use a code block in figure brackets:
 
 ```js
 if (year == 2015) {
@@ -101,7 +101,7 @@ if (year < 2015) {
 }
 ```
 
-In the code above JavaScript first checks `year < 2015`, if it is falsy then goes to the next condition `year > 2015`, and otherwise shows the last `alert`.
+In the code above JavaScript first checks `year < 2015`. If it is falsy it then goes to the next condition `year > 2015`, and otherwise shows the last `alert`.
 
 There can be more `else if` blocks. The ending `else` is optional.
 
@@ -128,7 +128,7 @@ alert(accessAllowed);
 
 The so-called "ternary" or "question mark" operator lets us do that shorter and simpler.
 
-The operator is represented by a question mark `"?"`.  The formal term "ternary" means that the operator has 3 operands. It is actually the one and only operator in JavaScript which has that many.
+The operator is represented by a question mark `"?"`.  The formal term "ternary" means that the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
 
 The syntax is:
 ```js
@@ -151,7 +151,7 @@ Technically, we can omit parentheses around `age > 18`. The question mark operat
 let accessAllowed = age > 18 ? true : false;
 ```
 
-...But parentheses make the code more readable. So it's recommended to put them.
+...But parentheses make the code more readable. So it's recommended to use them.
 
 ````smart
 In the example above it's possible to evade the question mark operator, because the comparison by itself returns `true/false`:
@@ -214,13 +214,13 @@ let company = prompt('Which company created JavaScript?', '');
 
 Depending on the condition `company == 'Netscape'`, either the first or the second part after `"?"` gets executed and shows the alert.
 
-We don't assign a result to a variable here, the idea is to execute different code depending on the condition.
+We don't assign a result to a variable here. The idea is to execute different code depending on the condition.
 
 **It is not recommended to use the question mark operator in this way.**
 
-The notation seem to be shorter than `if`, that appeals to some programmers. But it is less readable.
+The notation seems to be shorter than `if`, which appeals to some programmers. But it is less readable.
 
-Here is the same with `if` for comparison:
+Here is the same code with `if` for comparison:
 
 ```js run no-beautify
 let company = prompt('Which company created JavaScript?', '');

1-js/02-first-steps/11-logical-operators/article.md

@@ -41,7 +41,7 @@ if (1 || 0) { // works just like if( true || false )
 }
 ```
 
-Most of the time, OR `||` is used in `if` to test if *any* of given conditions is correct.
+Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is correct.
 
 For example:
 
@@ -80,13 +80,13 @@ result = value1 || value2 || value3;
 
 The OR `"||"` operator does the following:
 
-- Evalute operands from left to right.
-- For each operand, convert it to boolean. If the result is `true`, then stop and return that the original value of that operand.
+- Evaluate operands from left to right.
+- For each operand, convert it to boolean. If the result is `true`, then stop and return the original value of that operand.
 - If all other operands have been assessed (i.e. all were `falsy`), return the last operand.
 
 A value is returned in its original form, without the conversion.
 
-In other words, a chain of OR `"||"` returns the first truthy value or the last one if no such value found.
+In other words, a chain of OR `"||"` returns the first truthy value or the last one if no such value is found.
 
 For instance:
 
@@ -147,7 +147,7 @@ That leads to some interesting usages compared to a "pure, classical, boolean-on
 
     An assignment is a simple case, other side effects can be involved.
 
-    As we can see, such use case is a "shorter way to do `if`". The first operand is converted to boolean and if it's false then the second one is evaluated.
+    As we can see, such a use case is a "shorter way to do `if`". The first operand is converted to boolean and if it's false then the second one is evaluated.
 
     Most of time it's better to use a "regular" `if` to keep the code easy to understand, but sometimes that can be handy.
 
@@ -198,7 +198,7 @@ result = value1 && value2 && value3;
 
 The AND `"&&"` operator does the following:
 
-- Evalute operands from left to right.
+- Evaluate operands from left to right.
 - For each operand, convert it to a boolean. If the result is `false`, stop and return the original value of that operand.
 - If all other operands have been assessed (i.e. all were truthy), return the last operand.
 

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

@@ -2,7 +2,7 @@
 
 We often have a need to perform similar actions many times in a row.
 
-For example, when we need to output goods from the list one after another. Or just run the same code for each number from 1 to 10.
+For example, when we need to output goods from a list one after another. Or just run the same code for each number from 1 to 10.
 
 *Loops* are a way to repeat the same part of code multiple times.
 
@@ -19,7 +19,7 @@ while (condition) {
 }
 ```
 
-While the `condition` is `true` -- the `code` from the loop body is executed.
+While the `condition` is `true`, the `code` from the loop body is executed.
 
 For instance, the loop below outputs `i` while `i<3`:
 
@@ -31,7 +31,7 @@ while (i < 3) { // shows 0, then 1, then 2
 }
 ```
 
-A single execution of the loop body is called *an iteration*. The loop in the example above makes 3 iterations.
+A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations.
 
 If there were no `i++` in the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and for server-side JavaScript we can kill the process.
 
@@ -70,7 +70,7 @@ do {
 } while (condition);
 ```
 
-The loop will first execute the body, then check the condition, and while it's truthy -- execute it again and again.
+The loop will first execute the body, then check the condition and, while it's truthy, execute it again and again.
 
 For example:
 
@@ -82,7 +82,7 @@ do {
 } while (i < 3);
 ```
 
-This form of syntax is rarely used except when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other  form is preferred: `while(…) {…}`.
+This form of syntax is rarely used except when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.
 
 ## The "for" loop
 
@@ -231,7 +231,7 @@ alert( 'Sum: ' + sum );
 
 The `break` directive is activated in the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing the control to the first line after the loop. Namely, `alert`.
 
-The combination: "infinite loop + `break` as needed" is great for situations when the condition must be checked not in beginning/end of the loop, but in the middle. Or even in several places of the body.
+The combination "infinite loop + `break` as needed" is great for situations when the condition must be checked not in the beginning/end of the loop, but in the middle, or even in several places of the body.
 
 ## Continue to the next iteration [#continue]
 
@@ -266,7 +266,7 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
-From the technical point of view it's identical to the example above. Surely, we can just wrap the code in the `if` block instead of `continue`.
+From a technical point of view it's identical to the example above. Surely, we can just wrap the code in the `if` block instead of `continue`.
 
 But as a side-effect we got one more figure brackets nesting level. If the code inside `if` is longer than a few lines, that may decrease the overall readability.
 ````
@@ -360,12 +360,12 @@ outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-The `continue` directive can also be used with a label. In this case the execution jumps to the next iteration of the labelled loop.
+The `continue` directive can also be used with a label. In this case the execution jumps to the next iteration of the labeled loop.
 
 ````warn header="Labels are not a \"goto\""
-Labels do not allow to jump into an arbitrary place of code.
+Labels do not allow us to jump into an arbitrary place of code.
 
-For example, it is impossible to do like this:
+For example, it is impossible to do this:
 ```js
 break label;  // jumps to label? No.
 
@@ -379,12 +379,12 @@ The call to a `break/continue` is only possible from inside the loop, and the la
 
 We covered 3 types of loops:
 
-- `while` -- the condition is checked before each iteration.
-- `do..while` -- the condition is checked after each iteration.
-- `for(;;)` -- the condition is checked before each iteration, additional settings available.
+- `while` -- The condition is checked before each iteration.
+- `do..while` -- The condition is checked after each iteration.
+- `for(;;)` -- The condition is checked before each iteration, additional settings available.
 
 To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive.
 
-If we don't want to do anything on the current iteration and would like to forward to the next one -- the `continue` directive does it.
+If we don't want to do anything on the current iteration and would like to forward to the next one, the `continue` directive does it.
 
 `Break/continue` support labels before the loop. A label is the only way for `break/continue` to escape the nesting and go to the outer loop.

1-js/02-first-steps/13-switch/article.md

@@ -28,9 +28,9 @@ switch(x) {
 }
 ```
 
-- The value of `x` is checked for a strict equality to the value from the first `case`, that is: `value1`, then to the second `value2` and so on.
-- If the equality is found -- `switch` starts to execute the code starting from the corresponding `case`, and to the nearest `break` (or to the end of `switch`).
-- If no case matched then the `default` code is executed (if exists).
+- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
+- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`).
+- If no case is matched then the `default` code is executed (if it exists).
 
 ## An example
 
@@ -58,7 +58,7 @@ switch (a) {
 
 Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails.
 
-Then `4`. That's the match, so the execution starts from `case 4` and till the nearest `break`.
+Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`.
 
 **If there is no `break` then the execution continues with the next `case` without any checks.**
 
@@ -89,8 +89,8 @@ alert( 'Too big' );
 alert( "I don't know such values" );
 ```
 
-````smart header="Any expresion can be a `switch/case` argument"
-Both `switch` and case allow arbitrary expressions.
+````smart header="Any expression can be a `switch/case` argument"
+Both `switch` and `case` allow arbitrary expressions.
 
 For example:
 
@@ -141,7 +141,7 @@ switch (a) {
 
 Now both `3` and `5` show the same message.
 
-The ability to "group" cases a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
+The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
 
 ## Type matters