Fixed typos

Author: danwit

ebook/01_var_let_const.md

@@ -125,7 +125,7 @@ let j = "I am a let";
 `var` can be accessed **before** they are defined, but we can't access their **value**.
 `let` and `const` can't be accessed **before we define them**.
 
-Despite what you may read on other sources, both `var` and `let`(and `const`) are subject to **hoisting** which measn thath they are processe before any code is executed and lifted up to the top of their scope (whether it's global or block).
+Despite what you may read on other sources, both `var` and `let`(and `const`) are subject to **hoisting** which means that they are processed before any code is executed and lifted up to the top of their scope (whether it's global or block).
 
 The main differences lays in the fact that `var` can still be accessed before they are defined, causing the value to be `undefined` while on the other hand, `let` variables sit in a **temporal dead zone** until they are declared, causing an error when accessed before initialization which makes it easier to debug code rather than having an `undefined` as the result.
 

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 conciceness 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 funciton like this if you are working in a team and not everybody is totally up-to-date with ES6.
 
 ```js
 const arrowFunction = (name) => {
@@ -208,7 +208,7 @@ ReferenceError: arguments is not defined
 
 To access all the arguments passed to the function we can either use the old function notation or the spread syntax(which we will discuss more in Chapter 9)
 
-Remember that `arguments` it's just a keyword, it's not a variable name.
+Remember that `arguments` is just a keyword, it's not a variable name.
 
 Example with **arrow function**:
 
@@ -230,4 +230,4 @@ const showWinner = function() {
 }
 showWinner("Usain Bolt", "Justin Gatlin", "Asafa Powell")
 // "Usain Bolt was the winner"
-```
+```

ebook/03_default_function_arguments.md

@@ -20,7 +20,7 @@ getLocation('Paris','France')
 // Europe France Paris
 ```
 
-As you can see our function taskes three arguments, a city, a country and a continent. In the function body we are checking if either country or continent are `undefined` and in that case we are giving them a **default value**.
+As you can see our function takes three arguments, a city, a country and a continent. In the function body we are checking if either country or continent are `undefined` and in that case we are giving them a **default value**.
 
 When calling `getLocation('Milan')` the second and third parameter (country and continent) are undefined and get replaced by the default values of our functions.
 
@@ -90,7 +90,7 @@ const bill = calculatePrice({ tip: 0.15, total:150 });
 
 We made the argument of our function an Object and when calling the function we don't even have to worry about the order of the parameters because they will be matched based on their key.
 
-In the example above the default value for *tip* was 0.05 and we overrode it with 0.15 but we didn't give a value to tax which remained the default 0.1.
+In the example above the default value for *tip* was 0.05 and we overwrote it with 0.15 but we didn't give a value to tax which remained the default 0.1.
 
 Notice this detail:
 
@@ -120,4 +120,4 @@ calculatePrice(undefined)
 
 No matter what we passed, the argument was defaulted to an `Object` which had three default properties of total, tax and tip.
 
-Don't worry about destructuring, we will talk about it in Chapter 10.
+Don't worry about destructuring, we will talk about it in Chapter 10.

ebook/07_iterables-and-looping.md

@@ -117,7 +117,7 @@ for (const digit of digits) {
 // 1 3 5 7 9
 ```
 
-The last important difference I want to talk is that the `for in` loop will iterate over new properties added to the object.
+The last important difference I want to talk about is that the `for in` loop will iterate over new properties added to the object.
 
 ```js
 const fruit = ["apple","banana", "orange"];

ebook/08_array_improvements.md

@@ -4,7 +4,7 @@
 
 `Array.from()` is the first of the many new array methods that ES6 introduced.
 
-It will take something **arrayish**, meaning something that looks like an array but it isn't, and transform it into a real array.
+It will take something **arrayish**, meaning something that looks like an array but isn't, and transform it into a real array.
 
 ```html
 <div class="fruits">
@@ -128,4 +128,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.

ebook/10_object_literal_upgrades.md

@@ -99,7 +99,7 @@ var name = "myname";
 var person = {}
 // update the object
 person[name] = "Alberto";
-console.log(person.name);
+console.log(person.myname);
 // Alberto
 ```
 
@@ -112,6 +112,6 @@ const name = "myname";
 const person = {
   [name]:"Alberto",
 };
-console.log(person.name);
+console.log(person.myname);
 // Alberto
-```
+```

ebook/12_classes.md

@@ -33,7 +33,7 @@ Ok, now that I refreshed your knowledge of prototypal inheritance, let's have a
 
 ## Create a `Class`
 
-There are two way of creating a class:
+There are two ways of creating a class:
 
 - class declaration
 - class expression
@@ -101,7 +101,7 @@ Person.info();
 
 ## `set` and `get`
 
-We use setter and getter methods to set and get values inside our `Class`.
+We can use setter and getter methods to set and get values inside our `Class`.
 
 ```js
 class Person {
@@ -247,4 +247,4 @@ for(const student of myClass) {
 // Object { name: "Jim", grade: 8 }
 // Object { name: "Jon", grade: 10 }
 // Object { name: "Timmy", grade: 7 }
-```
+```

ebook/13_promises.md

@@ -247,7 +247,7 @@ Promise
 // first value second value
 ```
 
-Our values returned together, after 1000ms (the timeout of the *second* promise) meaning that the first one had to wait the completion of the second one.
+Our values returned together, after 1000ms (the timeout of the *second* promise) meaning that the first one had to wait for the completion of the second one.
 
 If we were to pass an empty iterable then it will return an already resolved promise.
 
@@ -274,7 +274,7 @@ Promise
   // Error: oooops error
 ```
 
-`Promise.race()` on the other hand returns a promises that resolves or rejects as soon as one of the promises in the iterable resolves or reject, with the value from that promise.
+`Promise.race()` on the other hand returns a promise that resolves or rejects as soon as one of the promises in the iterable resolves or reject, with the value from that promise.
 
 ``` js
 const promise1 =  new Promise((resolve,reject) => {
@@ -291,4 +291,4 @@ Promise.race([promise1, promise2]).then(function(value) {
 // expected output: "second value"
 ```
 
-If we passed an empty iterable, the race would be pending forever!.
+If we passed an empty iterable, the race would be pending forever!.

ebook/16_sets_weaksets_maps_weakmaps.md

@@ -28,7 +28,7 @@ console.log(family);
 
 As you can see, at the end we tried to add "Dad" again,but the `Set` still remained the same because a `Set` can only take **unique values**.
 
-Let's continue using the same `Set` and see what method we can use on it.
+Let's continue using the same `Set` and see what methods we can use on it.
 
 ``` js
 family.size;
@@ -193,4 +193,4 @@ myWeakMap;
 // WeakMap {}
 ```
 
-As you can see *mom* was garbage collected after we set the its value to `null` whilst *dad* still remains inside our `Map`.
+As you can see *mom* was garbage collected after we set the its value to `null` whilst *dad* still remains inside our `Map`.

ebook/18_ES2017_string-padding-object-entries-object-values-and-more.md

@@ -128,7 +128,7 @@ Object.getOwnPropertyDescriptors(myObj);
 
 ## Trailing commas in function parameter lists and calls
 
-This is just a minor change to a syntax. Now, when writing objects we can to leave a trailing comma after each parameter, whether or not it is the last one.
+This is just a minor change to a syntax. Now, when writing objects we can leave a trailing comma after each parameter, whether or not it is the last one.
 
 ``` js
 // from this
@@ -178,4 +178,4 @@ Examples of its methods are:
 
 - add / sub
 - and / or / xor
-- load / store
+- load / store