fix typos

Author: AlbertoMontalesi

README.md

@@ -21,8 +21,6 @@ This book is intended for somebody already familiar with the basics of JavaScrip
 
 Additional chapters cover the new features introduced post ES6 (ES2015) all the way to the most recent version, ES2018.
 
-## Download
-
 
 ## About me
 

ebook/00_introduction.md

@@ -0,0 +1,28 @@
+# Introduction
+
+This book is the sum of all my study on JavaScript throughout the past few months.
+As as self-taught web developer I read books, watched tutorials and read articles to keep myself updated to the newest version of JavaScript and while doing so I took several notes.
+
+I have now compiled all these notes in a concise book, covering almost all the new features that have been added to JavaScript since 2015 until 2018.
+
+Writing this book has been a long journey but the end result makes me really proud of having started writing it.
+
+As a self-taught developer I know the importance of sharing knowledge and materials and that is why this book can be read online on my [website](https://www.inspiredwebdev.com/courses/the-complete-guide-to-modern-javascript/) or on [GitHub](https://github.com/AlbertoMontalesi/JavaScript-es6-and-beyond-ebook) where more than 170 people already showed their appreciation for it.
+
+**Disclaimer**
+
+This book is intended for somebody already familiar with the basics of JavaScript, as I am only focusing on the new features introduced by ES6 and I won't be explaining what is a `var`, how to create a function, etc...
+
+Additional chapters cover the new features introduced post ES6 (ES2015) all the way to the most recent version, ES2018.
+
+ 
+
+## Contributions & Donations
+
+Any contributions you make are of course greatly appreciated.
+
+If you enjoy my content and you want to donate me a cup of coffee, you can do so [here](https://www.paypal.me/albertomontalesi).
+
+## License
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-nd/3.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/">Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License</a>.

ebook/01_var_let_const.md

@@ -26,7 +26,7 @@ console.log(functionScoped);
 // ReferenceError: functionScoped is not defined
 ```
 
-In the first example the value of the `var`  leaked out of the block-scope and could be accessed from outside, whereas in the second example `var` was confined inside a function-scope and we could not access it from outside.
+In the first example the value of the `var`  leaked out of the block-scope and could be accessed from outside of it, whereas in the second example `var` was confined inside a function-scope and we could not access it from outside.
 
  
 
@@ -68,7 +68,7 @@ As you can see, when we assigned a new value to our `let` inside our block-scope
 
 ## `Const`
 
-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  redeclared**.
+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
@@ -93,11 +93,13 @@ const person = {
 }
 
 person.age = 26;
-
+console.log(person.age);
+// 26
 // in this case no error will be raised, we are not re-assigning the variable but just one of its properties.
-``` 
+```
 
 ---
+
  
 
 ## The temporal dead zone

ebook/02_arrow_functions.md

@@ -6,9 +6,9 @@ ES6 introduced fat arrows (`=>`) as a way to declare functions.
 This is how we would normally declare a function in ES5:
 
 ``` javascript
-var greeting = (function(name) {
+var greeting = function(name) {
   return "hello " + name;
-})
+}
 ```
 
 The new syntax with a fat arrow looks like this:
@@ -35,7 +35,6 @@ const greeting = () => {
 }
 ```
 
-
  
 
 ## Implicitly return
@@ -55,10 +54,9 @@ const runners = [ "Usain Bolt", "Justin Gatlin", "Asafa Powell" ];
 const winner = runners.map((runner, i) =>  ({ name: runner, race, place: i + 1}));
 
 console.log(winner);
-// 0: {name: "Usain Bolt", race: "100m dash", place: 1}
-// 1: {name: "Justin Gatlin", race: "100m dash", place: 2}
-// 2: {name: "Asafa Powell", race: "100m dash", place: 3}
-
+// {name: "Usain Bolt", race: "100m dash", place: 1}
+// {name: "Justin Gatlin", race: "100m dash", place: 2}
+// {name: "Asafa Powell", race: "100m dash", place: 3}
 ```
 
 To tell JavaScript that what's inside the curly braces is an **object literal** that we want to implicitly return, we need to wrap everything inside parenthesis.
@@ -116,7 +114,7 @@ Since we know that **arrow functions** inherit the value of `this` from the pare
 ``` 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");
@@ -127,8 +125,7 @@ box.addEventListener("click", function () {
 });
 ```
 
-Here, the second `this` will inherit from its parent, and will be therefore set to the `const` box.
-
+Here, the second `this` will inherit from its parent, and will be set to the `const` box.
 
  
 
@@ -141,7 +138,7 @@ The next 2 examples all show when to be careful using `this` inside of arrows.
 ``` javascript
 const button = document.querySelector("btn");
 button.addEventListener("click", () => {
-  // error: *this* refers to the window 
+  // error: *this* refers to the `Window` Object
   this.classList.toggle("on");
 })
 ```
@@ -150,7 +147,7 @@ button.addEventListener("click", () => {
 const person = {
   age: 10,
   grow: () => {
-    // error: *this* refers to the window
+    // error: *this* refers to the `Window` Object
     this.age++;
   }
 }
@@ -183,6 +180,4 @@ const orderRunners = (...args) => {
     return `#{runner} was number #{i +1}`;
   })
 }
-
-```
-
+```

ebook/03_default_function_arguments.md

@@ -35,4 +35,4 @@ const Bill = calculatePrice({ tip: 0.15, total:150 });
 
 We don't even have to pass the parameters in the same order as when we declared our function, since we are calling them the same way as the arguments JavaScript will know how to match them.
 
-Don't worry about destructuring, we will talk about it in a later chapter.
+Don't worry about destructuring, we will talk about it in Chapter 6.

ebook/04_template_literals.md

@@ -142,7 +142,6 @@ const markup = `
 
  
 
-
 ## Tagged template literals
 
 By tagging a function to a template literal we can run the template literal through the function, providing it with everything that's inside of the template.
@@ -171,7 +170,6 @@ console.log(sentence);
 We captured the value of the variable age and used a ternary operator to decide what to print.
 `strings` will take all the strings of our `let` sentence whilst the other parameters will hold the variables.
 
-
  
 
 To learn more about use cases of *template literals* check out [this article](https://codeburst.io/javascript-es6-tagged-template-literals-a45c26e54761).

ebook/05_additional_string_methods.md

@@ -91,5 +91,4 @@ As the name suggests, this new method will repeat what we pass in.
 let hello = "Hi";
 console.log(hello.repeat(10));
 // "HiHiHiHiHiHiHiHiHiHi"
-```
-
+```

ebook/06_destructuring.md

@@ -6,7 +6,6 @@ MDN defines **destructuring** like this:
 
 Let's start with **destructuring objects** first.
 
-
  
 
 ## Destructuring Objects
@@ -95,7 +94,6 @@ console.log(name,surname);
 
 Let's say we want to grab all the other values remaining, we can use the **rest operator**:
 
-
 ```js
 const person = ["Alberto", "Montalesi", "pizza", "ice cream", "cheese cake"];
 // we use the **rest operator** to grab all the remaining values
@@ -104,14 +102,12 @@ console.log(food);
 // Array [ "pizza", "ice cream", "cheese cake" ]
 ```
 
-
  
 
 ## Swapping variables with destructuring
 
 The destructuring assignment makes it **extremely easy** to swap variables, just look at this example:
 
-
 ```js
 let hungry = "yes";
 let full = "no";
@@ -136,4 +132,4 @@ function totalBill({ total, tax = 0.1 }) {
 // as you see since we are using the same names, we don't have to pass the arguments in the same order as when we declared the function
 // we are also overriding the default value we set for the tax
 const bill = totalBill({ tax: 0.15, total: 150});
-
+```

ebook/07_iterables-and-looping.md

@@ -58,15 +58,13 @@ for (const prop of Object.keys(car)){
 
  
 
-
 ## The `for in` loop
 
 Even though it is not a new ES6 loop, let's look at the `for in` loop to understand what differentiate it compared to the `for of.
 
 The `for in` loop is a bit different because it will iterate over all the [enumerable properties](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties) of an object in no particular order.
 
-It is therefore suggested not to add, modify or delete properties of the object during the iteration as there is no guarantee that they will be visited, or if they will be visited before or after being modified. 
-
+It is therefore suggested not to add, modify or delete properties of the object during the iteration as there is no guarantee that they will be visited, or if they will be visited before or after being modified.
 
 ```js
 const car = {
@@ -101,7 +99,6 @@ for (let i in list) {
 for (let i of list) {
    console.log(i); // "4", "5", "6"
 }
-
 ```
 
 `for in` will return a list of keys whereas the `for of` will return a list of values of the numeric properties of the object being iterated.

ebook/08_array_improvements.md

@@ -69,7 +69,6 @@ console.log(digits);
 // Array [ 1, 2, 3, 4, 5];
 ```
 
-
  
 
 ## `Array.find()`
@@ -125,5 +124,4 @@ console.log(arrayEvery);
 // false
 ```
 
-Simply put, the first condition is true, because there are **some** elements greater than 2, but the second is false because **not every element** is greater than 2.
-
+Simply put, the first condition is true, because there are **some** elements greater than 2, but the second is false because **not every element** is greater than 2.