run prettier and fix typos

Author: mathieudutour

Diff for: .gitignore

@@ -1,3 +1,4 @@
 node_modules
 .grunt
 /_book/
+.vscode

Diff for: README.md

@@ -1,8 +1,7 @@
-Learn Javascript
-======
+# Learn Javascript
 
 This book will teach you the basics of programming and Javascript. Whether you are an experienced programmer or not, this book is intended for everyone who wishes to learn the JavaScript programming language.
 
 ![Screen](./assets/intro.png)
 
-JavaScript (*JS for short*) is the programming language that enables web pages to respond to user interaction beyond the basic level. It was created in 1995, and is today one of the most famous and used programming languages.
+JavaScript (_JS for short_) is the programming language that enables web pages to respond to user interaction beyond the basic level. It was created in 1995, and is today one of the most famous and used programming languages.

Diff for: SUMMARY.md

@@ -1,40 +1,39 @@
 # Summary
 
-* [Basics](basics/README.md)
-    * [Comments](basics/comments.md)
-    * [Variables](basics/variables.md)
-    * [Types](basics/types.md)
-    * [Equality](basics/equality.md)
-* [Numbers](numbers/README.md)
-    * [Creation](numbers/create.md)
-    * [Basic Operators](numbers/operators.md)
-    * [Advanced Operators](numbers/advanced.md)
-* [Strings](strings/README.md)
-    * [Creation](strings/create.md)
-    * [Concatenation](strings/concat.md)
-    * [Length](strings/length.md)
-* [Conditional Logic](conditional/README.md)
-    * [If](conditional/if.md)
-    * [Else](conditional/else.md)
-    * [Comparators](conditional/comparators.md)
-    * [Concatenate](conditional/concatenate.md)
-* [Arrays](arrays/README.md)
-    * [Indices](arrays/indices.md)
-    * [Length](arrays/length.md)
-* [Loops](loops/README.md)
-    * [For](loops/for.md)
-    * [While](loops/while.md)
-    * [Do...While](loops/dowhile.md)
-* [Functions](functions/README.md)
-    * [Declare](functions/declare.md)
-    * [Higher order](functions/higher_order.md)
-* [Objects](objects/README.md)
-    * [Creation](objects/creation.md)
-    * [Properties](objects/properties.md)
-    * [Mutable](objects/mutable.md)
-    * [Reference](objects/reference.md)
-    * [Prototype](objects/prototype.md)
-    * [Delete](objects/delete.md)
-    * [Enumeration](objects/enumeration.md)
-    * [Global footprint](objects/global_footprint.md)
-
+- [Basics](basics/README.md)
+  - [Comments](basics/comments.md)
+  - [Variables](basics/variables.md)
+  - [Types](basics/types.md)
+  - [Equality](basics/equality.md)
+- [Numbers](numbers/README.md)
+  - [Creation](numbers/create.md)
+  - [Basic Operators](numbers/operators.md)
+  - [Advanced Operators](numbers/advanced.md)
+- [Strings](strings/README.md)
+  - [Creation](strings/create.md)
+  - [Concatenation](strings/concat.md)
+  - [Length](strings/length.md)
+- [Conditional Logic](conditional/README.md)
+  - [If](conditional/if.md)
+  - [Else](conditional/else.md)
+  - [Comparators](conditional/comparators.md)
+  - [Concatenate](conditional/concatenate.md)
+- [Arrays](arrays/README.md)
+  - [Indices](arrays/indices.md)
+  - [Length](arrays/length.md)
+- [Loops](loops/README.md)
+  - [For](loops/for.md)
+  - [While](loops/while.md)
+  - [Do...While](loops/dowhile.md)
+- [Functions](functions/README.md)
+  - [Declare](functions/declare.md)
+  - [Higher order](functions/higher_order.md)
+- [Objects](objects/README.md)
+  - [Creation](objects/creation.md)
+  - [Properties](objects/properties.md)
+  - [Mutable](objects/mutable.md)
+  - [Reference](objects/reference.md)
+  - [Prototype](objects/prototype.md)
+  - [Delete](objects/delete.md)
+  - [Enumeration](objects/enumeration.md)
+  - [Global footprint](objects/global_footprint.md)

Diff for: arrays/README.md

@@ -9,4 +9,4 @@ Here is a simple array:
 ```javascript
 // 1, 1, 2, 3, 5, and 8 are the elements in this array
 var numbers = [1, 1, 2, 3, 5, 8];
-```
+```

Diff for: arrays/length.md

@@ -3,7 +3,7 @@
 Arrays have a property called length, and it's pretty much exactly as it sounds, it's the length of the array.
 
 ```javascript
-var array = [1 , 2, 3];
+var array = [1, 2, 3];
 
 // Result: l = 3
 var l = array.length;

Diff for: basics/README.md

@@ -4,7 +4,7 @@ In this first chapter, we'll learn the basics of programming and the Javascript
 
 Programming means writing code. A book is made up of chapters, paragraphs, sentences, phrases, words and finally punctuation and letters, likewise a program can be broken down into smaller and smaller components. For now, the most important is a statement. A statement is analogous to a sentence in a book. On its own, it has structure and purpose, but without the context of the other statements around it, it isn't that meaningful.
 
-A statement is more casually (and commonly) known as a *line of code*. That's because statements tend to be written on individual lines. As such, programs are read from top to bottom, left to right. You might be wondering what code (also called source code) is. That happens to be a broad term which can refer to the whole of the program or the smallest part. Therefore, a line of code is simply a line of your program.
+A statement is more casually (and commonly) known as a _line of code_. That's because statements tend to be written on individual lines. As such, programs are read from top to bottom, left to right. You might be wondering what code (also called source code) is. That happens to be a broad term which can refer to the whole of the program or the smallest part. Therefore, a line of code is simply a line of your program.
 
 Here is a simple example:
 
@@ -16,4 +16,4 @@ var world = "World";
 var message = hello + " " + world;
 ```
 
-This code can be executed by another program called an *interpreter* that will read the code, and execute all the statements in the right order.
+This code can be executed by another program called an _interpreter_ that will read the code, and execute all the statements in the right order.

Diff for: basics/comments.md

@@ -4,14 +4,14 @@ Comments are statements that will not be executed by the interpreter, comments a
 
 In Javascript, comments can be written in 2 different ways:
 
-* Line starting with `//`:
+- Line starting with `//`:
 
 ```javascript
 // This is a comment, it will be ignored by the interpreter
 var a = "this is a variable defined in a statement";
 ```
 
-* Section of code starting with `/*`and ending with `*/`, this method is used for multi-line comments:
+- Section of code starting with `/*`and ending with `*/`, this method is used for multi-line comments:
 
 ```javascript
 /*
@@ -20,28 +20,3 @@ it will be ignored by the interpreter
 */
 var a = "this is a variable defined in a statement";
 ```
-
-
----
-
-Mark the editor's contents as a comment
-
-```js
-
-Mark me as a comment
-or I'll throw an error
-
-```
-
-```js
-/*
-Mark me as a comment
-or I'll throw an error
-*/
-```
-
-```js
-assert(true);
-```
-
----

Diff for: basics/equality.md

@@ -2,16 +2,17 @@
 
 Programmers frequently need to determine the equality of variables in relation to other variables. This is done using an equality operator.
 
-The most basic equality operator is the `==` operator. This operator does everything it can to determine if two variables are equal, even if they are not of the same type. 
+The most basic equality operator is the `==` operator. This operator does everything it can to determine if two variables are equal, even if they are not of the same type.
 
 For example, assume:
+
 ```javascript
 var foo = 42;
 var bar = 42;
 var baz = "42";
 var qux = "life";
 ```
 
-`foo == bar` will evaluate to `true` and `baz == qux` will evaluate to `false`, as one would expect. However, `foo == baz` will *also* evaluate to `true` despite `foo` and `baz` being different types. Behind the scenes the `==` equality operator attempts to force its operands to the same type before determining their equality. This is in contrast to the `===` equality operator.
+`foo == bar` will evaluate to `true` and `baz == qux` will evaluate to `false`, as one would expect. However, `foo == baz` will _also_ evaluate to `true` despite `foo` and `baz` being different types. Behind the scenes the `==` equality operator attempts to force its operands to the same type before determining their equality. This is in contrast to the `===` equality operator.
 
-The `===` equality operator determines that two variables are equal if they are of the same type *and* have the same value. With the same assumptions as before, this means that `foo === bar` will still evaluate to `true`,  but `foo === baz` will now evaluate to `false`. `baz === qux` will still evaluate to `false`.
+The `===` equality operator determines that two variables are equal if they are of the same type _and_ have the same value. With the same assumptions as before, this means that `foo === bar` will still evaluate to `true`, but `foo === baz` will now evaluate to `false`. `baz === qux` will still evaluate to `false`.

Diff for: basics/types.md

@@ -4,23 +4,24 @@ Computers are sophisticated and can make use of more complex variables than just
 
 The most common types are:
 
-* **Numbers**
-    * **Float**: a number, like 1.21323, 4, -33.5, 100004 or 0.123
-    * **Integer**: a number like 1, 12, -33, 140 but not 1.233
+- **Numbers**
 
-* **String**: a line of text like "boat", "elephant" or "damn, you are tall!"
+  - **Float**: a number, like 1.21323, 4, -33.5, 100004 or 0.123
+  - **Integer**: a number like 1, 12, -33, 140 but not 1.233
 
-* **Boolean**: either true or false, but nothing else
+- **String**: a line of text like "boat", "elephant" or "damn, you are tall!"
 
-* **Arrays**: a collection of values like: 1,2,3,4,'I am bored now'
+- **Boolean**: either true or false, but nothing else
 
-* **Objects**: a representation of a more complex object
+- **Arrays**: a collection of values like: 1,2,3,4,'I am bored now'
 
-* **null**: a variable that contains null contains no valid Number, String, Boolean, Array, or Object
+- **Objects**: a representation of a more complex object
 
-* **undefined**: the undefined value is obtained when you use an object property that does not exist, or a variable that has been declared, but has no value assigned to it.
+- **null**: a variable that contains null contains no valid Number, String, Boolean, Array, or Object
 
-JavaScript is a *“loosely typed”* language, which means that you don't have to explicitly declare what type of data the variables are. You just need to use the ```var``` keyword to indicate that you are declaring a variable, and the interpreter will work out what data type you are using from the context, and use of quotes.
+- **undefined**: the undefined value is obtained when you use an object property that does not exist, or a variable that has been declared, but has no value assigned to it.
+
+JavaScript is a _“loosely typed”_ language, which means that you don't have to explicitly declare what type of data the variables are. You just need to use the `var` keyword to indicate that you are declaring a variable, and the interpreter will work out what data type you are using from the context, and use of quotes.
 
 {% exercise %}
 Create a variable named `a` using the keyword `var`.

Diff for: conditional/README.md

@@ -6,4 +6,4 @@ First of all conditions can be used to ensure that your program works, regardles
 
 The other thing conditions can do for you is allow for branching. You might have encountered branching diagrams before, for example when filling out a form. Basically, this refers to executing different “branches” (parts) of code, depending on if the condition is met or not.
 
-In this chapter, we'll learn the base of conditional logic in Javascript.
+In this chapter, we'll learn the base of conditional logic in Javascript.

Diff for: conditional/comparators.md

@@ -8,17 +8,16 @@ if (country === "France") {
 }
 ```
 
-The conditional part is the variable `country` followed by the three equal signs (`===`). Three equal signs tests if the variable `country` has both the correct value (`France`) and also the correct type (`String`). You can test conditions with double equal signs, too, however a conditional such as `if (x == 5)` would then return true for both `var x = 5;` and `var x = "5";`. Depending on what your program is doing, this could make quite a difference.  It is highly recommended as a best practice that you always compare equality with three equal signs (`===` and `!==`) instead of two (`==` and `!=`).
+The conditional part is the variable `country` followed by the three equal signs (`===`). Three equal signs tests if the variable `country` has both the correct value (`France`) and also the correct type (`String`). You can test conditions with double equal signs, too, however a conditional such as `if (x == 5)` would then return true for both `var x = 5;` and `var x = "5";`. Depending on what your program is doing, this could make quite a difference. It is highly recommended as a best practice that you always compare equality with three equal signs (`===` and `!==`) instead of two (`==` and `!=`).
 
 Other conditional test:
 
-* ```x > a```: is x bigger than a?
-* ```x < a```: is x less than a?
-* ```x <= a```: is x less than or equal to a?
-* ```x >=a```: is x greater than or equal to a?
-* ```x != a```: is x not a?
-* ```x```: does x exist?
-
+- `x > a`: is x bigger than a?
+- `x < a`: is x less than a?
+- `x <= a`: is x less than or equal to a?
+- `x >=a`: is x greater than or equal to a?
+- `x != a`: is x not a?
+- `x`: does x exist?
 
 {% exercise %}
 Add a condition to change the value of `a` to the number 10 if `x` is bigger than 5.
@@ -30,7 +29,7 @@ var x = 6;
 var a = 0;
 
 if (x > 5) {
-    a = 10;
+a = 10;
 }
 {% validation %}
 assert(a === 10);
@@ -41,7 +40,7 @@ assert(a === 10);
 In order to avoid the if-else hassle, simple logical comparisons can be utilised.
 
 ```js
-var topper = (marks > 85) ? "YES" : "NO";
+var topper = marks > 85 ? "YES" : "NO";
 ```
 
 In the above example, `?` is a logical operator. The code says that if the value of marks is greater than 85 i.e. `marks > 85` , then `topper = YES` ; otherwise `topper = NO` . Basically, if the comparison condition proves true, the first argument is accessed and if the comparison condition is false , the second argument is accessed.

Diff for: conditional/concatenate.md

@@ -6,21 +6,21 @@ In JavaScript “or” is written as `||` and “and” is written as `&&`.
 
 Say you want to test if the value of x is between 10 and 20—you could do that with a condition stating:
 
-```
-if(x > 10 && x < 20) {
+```javascript
+if (x > 10 && x < 20) {
     ...
 }
 ```
 
 If you want to make sure that country is either “England” or “Germany” you use:
 
-```
-if(country === 'England' || country === 'Germany') {
+```javascript
+if (country === "England" || country === "Germany") {
     ...
 }
 ```
 
-**Note**: Just like operations on numbers, Condtions can be grouped using parenthesis, ex: ```if ( (name === "John" || name === "Jennifer") && country === "France")```.
+**Note**: Just like operations on numbers, Condtions can be grouped using parenthesis, ex: `if ( (name === "John" || name === "Jennifer") && country === "France")`.
 
 {% exercise %}
 Fill up the 2 conditions so that `primaryCategory` equals `"E/J"` only if name equals `"John"` and country is `"England"`, and so that `secondaryCategory` equals `"E|J"` only if name equals `"John"` or country is `"England"`
@@ -29,22 +29,22 @@ var name = "John";
 var country = "England";
 var primaryCategory, secondaryCategory;
 
-if ( /* Fill here */ ) {
-    primaryCategory = "E/J";
+if ( /_ Fill here _/ ) {
+primaryCategory = "E/J";
 }
-if ( /* Fill here */ ) {
-    secondaryCategory = "E|J";
+if ( /_ Fill here _/ ) {
+secondaryCategory = "E|J";
 }
 {% solution %}
 var name = "John";
 var country = "England";
 var primaryCategory, secondaryCategory;
 
 if (name === "John" && country === "England") {
-    primaryCategory = "E/J";
+primaryCategory = "E/J";
 }
 if (name === "John" || country === "England") {
-    secondaryCategory = "E|J";
+secondaryCategory = "E|J";
 }
 {% validation %}
 assert(primaryCategory === "E/J" && secondaryCategory === "E|J");

Diff for: conditional/else.md

@@ -5,26 +5,25 @@ There is also an `else` clause that will be applied when the first condition isn
 ```javascript
 var umbrellaMandatory;
 
-if(country === 'England'){
-    umbrellaMandatory = true;
+if (country === "England") {
+  umbrellaMandatory = true;
 } else {
-    umbrellaMandatory = false;
+  umbrellaMandatory = false;
 }
 ```
 
 The `else` clause can be joined with another `if`. Lets remake the example from the previous article:
 
 ```javascript
-if(country === 'England') {
-    ...
-} else if(country === 'France') {
-    ...
-} else if(country === 'Germany') {
-    ...
+if (country === "England") {
+  ...
+} else if (country === "France") {
+  ...
+} else if (country === "Germany") {
+  ...
 }
 ```
 
-
 {% exercise %}
 Fill up the value of `name` to validate the `else` condition.
 {% initial %}
@@ -33,15 +32,15 @@ var name =
 if (name === "John") {
 
 } else if (name === "Aaron") {
-    // Valid this condition
+// Valid this condition
 }
 {% solution %}
 var name = "Aaron";
 
 if (name === "John") {
 
 } else if (name === "Aaron") {
-    // Valid this condition
+// Valid this condition
 }
 {% validation %}
 assert(name === "Aaron");