Performs Markdown Lint and Spell Check

Author: AlbertoMontalesi

ebook/01_var_let_const.md

@@ -70,7 +70,6 @@ As you can see, when we assigned a new value to our `let` inside our block-scope
 
 Similarly to `let`, `const` are **block-scoped**, but they differ in the fact that their value **can't change through re-assignment or can't be re-declared**.
 
-
 ``` javascript
 const constant = 'I am a constant';
 constant = " I can't be reassigned";
@@ -100,7 +99,7 @@ In this case we are not reassigning the whole variable but just one of its prope
 
 ---
 
-Note: We can still freeze the const object, which will not change the contents of the object (but trying to change the values of object Javascript will not throw any error)
+Note: We can still freeze the const object, which will not change the contents of the object (but trying to change the values of object JavaScript will not throw any error)
 
 ``` javascript
 const person = {
@@ -160,7 +159,6 @@ The first opinion comes from [Mathias Bynes:](https://mathiasbynens.be/notes/es6
 - use `let` only if rebinding is needed.
 - `var` should never be used in ES6.
 
-
 The second opinion comes from [Kyle Simpson:](https://me.getify.com/)
 
 - Use `var` for top-level variables that are shared across many (especially larger) scopes.

ebook/02_arrow_functions.md

@@ -56,7 +56,7 @@ const arrowFunction = name => `hello ${name}`;
 ```
 
 Both functions achieve the same result, but the new syntax allows you to be more concise.
-Beware! Readability is more important than conciseness so you might want to write your funciton like this if you are working in a team and not everybody is totally up-to-date with ES6.
+Beware! Readability is more important than conciseness so you might want to write your function like this if you are working in a team and not everybody is totally up-to-date with ES6.
 
 ```js
 const arrowFunction = (name) => {
@@ -106,10 +106,10 @@ When you use an arrow function, the `this` keyword is inherited from the parent
 
 This can be useful in cases like this one:
 
-``` javascript 
+``` javascript
 // grab our div with class box
 const box = document.querySelector(".box");
-// listen for a click event 
+// listen for a click event
 box.addEventListener("click", function() {
   // toggle the class opening on the div
   this.classList.toggle("opening");
@@ -120,11 +120,10 @@ box.addEventListener("click", function() {
 });
 ```
 
-
 The problem in this case is that the first `this` is bound to the `const` box but the second one, inside the `setTimeout`, will be set to the `Window` object, throwing this error:
 
 ``` javascript
-Uncaught TypeError: cannot read property "toggle" of undefined 
+Uncaught TypeError: cannot read property "toggle" of undefined
 ```
 
 Since we know that **arrow functions** inherit the value of `this` from the parent scope, we can re-write our function like this:

ebook/03_default_function_arguments.md

@@ -108,9 +108,9 @@ If we don't default our argument Object to an empty Object, and we were to try a
 Cannot destructure property `total` of 'undefined' or 'null'.
 ```
 
-By writing ` = {}` we default our argument to an `Object` and no matter what argument we pass in the function, it will be an `Object`:
+By writing `= {}` we default our argument to an `Object` and no matter what argument we pass in the function, it will be an `Object`:
 
-``` js
+```js
 calculatePrice({});
 // 0
 calculatePrice();

ebook/04_template_literals.md

@@ -64,7 +64,7 @@ how are you?\ "
 
 In ES6 we simply have to wrap everything inside backticks, no more backslashes on each line.
 
-``` javascript 
+``` javascript
 const content = `hello,
 my name is Alberto
 how are you?`;
@@ -101,7 +101,6 @@ return isFridgeEmpty ? "$10" : "$20"
 
 If the condition before the `?` can be converted to `true` then the first value is returned, else it's the value after the `:` that gets returned.
 
-
 ``` js
 // create an artist with name and age
 const artist = {
@@ -148,7 +147,7 @@ const groceries = {
 // this function will map each individual value of our groceries
 function groceryList(others) {
   return `
-    <p> 
+    <p>
       ${others.map( other => ` <span> ${other}</span>`).join(' ')}
     </p>
   `;

ebook/05_additional_string_methods.md

@@ -2,46 +2,53 @@
 
 There are many methods that we can use against strings. Here's a list of a few of them:
 
-  1. **indexOf()**
-  
-  Gets the position of the first occurence of the specified value in a string.
-  ```js
-  const str = "this is a short sentence";
-  str.indexOf("short");
-  // Output: 10
-  ```
-  2. **slice()**
-  
-  Pulls a specified part of a string as a new string.
-  ```js
-  const str = "pizza, orange, cereals"
-  str.slice(0, 5);
-  // Output: "pizza"
-  ```
-  3. **toUpperCase()**
-  
-  Turns all characters of a string to uppercase.
-  ```js
-  const str = "i ate an apple"
-  str.toUpperCase()
-  // Output: "I ATE AN APPLE"
-  ```
-  4. **toLowerCase()**
-  
-  Turns all characters of a string to lowercase.
-  ```
-  const str = "I ATE AN APPLE"
-  str.toLowerCase()
-  // Output: "i ate an apple"
-  ```
+1. **indexOf()**
+
+Gets the position of the first occurrence of the specified value in a string.
+
+```js
+const str = "this is a short sentence";
+str.indexOf("short");
+// Output: 10
+```
+
+2. **slice()**
+
+Pulls a specified part of a string as a new string.
+
+```js
+const str = "pizza, orange, cereals"
+str.slice(0, 5);
+// Output: "pizza"
+```
+
+1. **toUpperCase()**
+
+Turns all characters of a string to uppercase.
+
+```js
+const str = "i ate an apple"
+str.toUpperCase()
+// Output: "I ATE AN APPLE"
+```
+
+4. **toLowerCase()**
+
+Turns all characters of a string to lowercase.
+
+```JS
+const str = "I ATE AN APPLE"
+str.toLowerCase()
+// Output: "i ate an apple"
+```
 
 There are many more methods, these were just a few as a reminder. Check the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#) for a more in-depth description on the above methods.
 
  
 
 ## Additional string methods
 
-ES6 intoduced 4 new string methods:
+ES6 introduced 4 new string methods:
 
 - `startsWith()`
 - `endsWith()`

ebook/06_destructuring.md

@@ -54,7 +54,6 @@ const { facebook } = person.links.social;
 
 We are not limited to name our variable the same as the property of the object, we can also rename it like this:
 
-
 ```js
 const { facebook:fb } = person.links.social;
 // it will look for the property person.links.social.facebook and name the variable fb

ebook/08_array_improvements.md

@@ -66,7 +66,6 @@ In the example above we passed a `map` function to the `.from()` method to push
 
 `Array.of()` will create an array with all the arguments we pass into it.
 
-
 ```js
 const digits = Array.of(1,2,3,4,5);
 console.log(digits);

ebook/11_symbols.md

@@ -33,7 +33,7 @@ They both have the same value, but we will never have naming collisions with Sym
 
 As we mentioned earlier we can use them to create identifiers for object properties, so let's see an example:
 
-``` js 
+``` js
 const office = {
   "Tom" : "CEO",
   "Mark": "CTO",
@@ -94,4 +94,4 @@ console.log(value);
 ​// length: 3
 ```
 
-Now we finally got the array containing all the values of our symbols.
+Now we finally got the array containing all the values of our symbols.

ebook/12_classes.md

@@ -3,7 +3,6 @@
 Quoting MDN:
 > classes are primarily syntactical sugar over js's existing prototype-based inheritance. The class syntax **does not** introduce a new object-oriented inheritance model to JavaScript.
 
-
 That being said, let's review prototypal inheritance before we jump into classes.
 
 ``` js
@@ -83,7 +82,7 @@ As you can see everything works just like before. As we mentioned at the beginni
 
 ## Static methods
 
-Right now the two new methods that we created, `greet()` and `farewell()` can be accessed by every new instance of `Person`, but what if we want a method that can only be accessed by the class itself, similarily to `Array.of()` for arrays?
+Right now the two new methods that we created, `greet()` and `farewell()` can be accessed by every new instance of `Person`, but what if we want a method that can only be accessed by the class itself, similarly to `Array.of()` for arrays?
 
 ```js
 static info(){
@@ -135,7 +134,6 @@ alberto.nicknames;
 
 What if we want to have a new `Class` that inherits from our previous one? We use `extends`:
 
-
 ``` js
 // our initial class
 class Person {
@@ -179,7 +177,7 @@ class Adult extends Person {
 }
 ```
 
-Why did we set `super(name,age)` ? Because our `Adult` class inherits name and age from the `Person` therefore we don't need to redeclare them. 
+Why did we set `super(name,age)` ? Because our `Adult` class inherits name and age from the `Person` therefore we don't need to redeclare them.
 Super will simply create a new Person for us.
 
 If we now run the code again we will get this:
@@ -203,7 +201,7 @@ We want to create something like this, something similar to an array where the f
 
 ``` js
 // we create a new Classroom
-const myClass = new Classroom('1A',[ 
+const myClass = new Classroom('1A',[
   {name: "Tim", mark: 6},
   {name: "Tom", mark: 3},
   {name: "Jim", mark: 8},
@@ -221,12 +219,12 @@ class Classroom extends Array {
     super(...students);
     this.name = name;
     // we create a new method to add students
-  } 
+  }
   add(student){
     this.push(student);
   }
 }
-const myClass = new Classroom('1A', 
+const myClass = new Classroom('1A',
   {name: "Tim", mark: 6},
   {name: "Tom", mark: 3},
   {name: "Jim", mark: 8},

ebook/13_promises.md

@@ -52,7 +52,7 @@ fs.readdir(source, function (err, files) {
 
 We try to write our code in a way where executions happens visually from top to bottom, causing excessive nesting on functions and result in what you can see above.
 
-To improve your callbacks you can check out http://callbackhell.com/
+To improve your callbacks you can check out [http://callbackhell.com/](http://callbackhell.com/)
 
 Here we will focus on how to write promises.
 
@@ -191,7 +191,7 @@ We did not get "first value" because we threw an error therefore we only got the
 ```js
 //Promise.resolve()
 Promise.resolve('Success').then(function(value) {
-  console.log(value); 
+  console.log(value);
   // "Success"
 }, function(value) {
   // not called