Merge pull request #13 from itsmesean/master

Fixed typos

Author: AlbertoMontalesi

README.md

@@ -21,15 +21,15 @@ Whether you are a complete beginner or you have some knowledge in JavaScript, th
 
 After reading this book, Let Const, generators, promises and async won't be a problem anymore.
 
-If you want to experience something new, this book also includes an introduction to the basics of TypeScript, a must-know for any JavaScript develop in 2019.
+If you want to experience something new, this book also includes an introduction to the basics of TypeScript, a must-know for any JavaScript developer in 2019.
 
 ## Where to buy it
 
 You can purchase this ebook on amazon.com at this [link](https://www.amazon.com/dp/B07S2M3FVV)
 
 You can also read my articles on my blog [here](https://www.inspiredwebdev.com/).
 
-The ebook includes two sections dedicated to the basics of JavaScript and TypeScript and also contains 50+ extra quizzes for your to practice and test your knowledge after reading each chapter.
+The ebook includes two sections dedicated to the basics of JavaScript and TypeScript and also contains 50+ extra quizzes for you to practice and test your knowledge after reading each chapter.
 You can have a look at the quizzes from the first two chapters in the `quizzes` folder.
 
 ## About me

ebook/01_var_let_const.md

@@ -104,12 +104,10 @@ In this case we are not reassigning the whole variable but just one of its prope
 
 ## The temporal dead zone
 
-Now we will have a look at a very important concept which may sound complicate from its name, but i reassure you it is not.
+Now we will have a look at a very important concept which may sound complicated from its name, but I assure you it is not.
 
 First let's have a look at a simple example:
 
-Let's look at an example:
-
 ```javascript
 console.log(i);
 var i = "I am a variable";
@@ -143,7 +141,7 @@ The first opinion comes from [Mathias Bynes:](https://mathiasbynens.be/notes/es6
 - `var` should never be used in ES6.
 
 
-The second opinion comes from [Kyle Simpson:]( blog.getify.com/constantly-confusing-const/)
+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.
 - Use `let` for localized variables in smaller scopes.

ebook/02_arrow_functions.md

@@ -78,7 +78,7 @@ console.log(results);
 // {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.
+To tell JavaScript what's inside the curly braces is an **object literal** we want to implicitly return, we need to wrap everything inside parenthesis.
 
 Writing `race` or `race: race` is the same.
 
@@ -121,7 +121,7 @@ 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, trowing this error:
+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 
@@ -187,7 +187,7 @@ example(1,2,3);
 
 As you can see we accessed the first argument using an array notation `arguments[0]`.
 
-Similarly as what we saw with the `this` keyword, Arrow functions inherit the value of the `arguments object` from their parent scope.
+Similarly to what we saw with the `this` keyword, Arrow functions inherit the value of the `arguments object` from their parent scope.
 
 Let's have a look at this example with our previous list of runners:
 

ebook/03_default_function_arguments.md

@@ -101,7 +101,7 @@ Notice this detail:
   tip = 0.05} = {}
 ```
 
-If we don't default our argument Object to an empty Object, if we were to try and run `calculatePrice()` we would get:
+If we don't default our argument Object to an empty Object, and we were to try and run `calculatePrice()` we would get:
 
 ```js
 Cannot destructure property `total` of 'undefined' or 'null'.

ebook/04_template_literals.md

@@ -16,7 +16,7 @@ console.log(greeting);
 // Hello my name is Alberto
 ```
 
-In ES6 we can use backticks to make our life easier.
+In ES6 we can use backticks to make our lives easier.
 
 ``` javascript
 let name  = "Alberto";
@@ -99,7 +99,7 @@ return isFridgeEmpty ? "$10" : "20"
 // $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 get returned.
+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

ebook/05_additional_string_methods.md

@@ -1,6 +1,6 @@
 # Chapter 5: Additional string methods
 
-There are many methods that we can use againt strings. Here's a list of a few of them:
+There are many methods that we can use against strings. Here's a list of a few of them:
 
 ```js
 // .length()

ebook/07_iterables-and-looping.md

@@ -59,7 +59,7 @@ 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`.
+Even though it is not a new ES6 loop, let's look at the `for in` loop to understand what differentiates it to the `for of` loop.
 
 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.
 
@@ -103,7 +103,7 @@ for (let i of list) {
 `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.
 
 
-Another differences is that we **can** stop a `for of` loop but we can't do the same with a `for in` loop.
+Another difference is that we **can** stop a `for of` loop but we can't do the same with a `for in` loop.
 
 ```js
 const digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

ebook/08_array_improvements.md

@@ -2,7 +2,7 @@
 
 ## `Array.from()`
 
-`Array.from()` is the first of the many new array methods that ES6 introduced.
+`Array.from()` is the first of many new array methods that ES6 introduced.
 
 It will take something **arrayish**, meaning something that looks like an array but isn't, and transform it into a real array.
 

ebook/11_symbols.md

@@ -82,7 +82,7 @@ console.log(symbols);
 ​// length: 3
 ```
 
-We retrieved the array but to be able to access the properties we havee to use `map`.
+We retrieved the array but to be able to access the properties we have to use `map`.
 
 ```js
 const symbols = Object.getOwnPropertySymbols(office);

ebook/12_classes.md

@@ -53,7 +53,7 @@ const person = class Person {
 
 Let's start creating our first `Class`.
 
-We only need a method called `constructor` (remember to add only one constructor, a `SyntaxError` will be thrown if the class contains more than one constructor methods).
+We only need a method called `constructor` (remember to add only one constructor, a `SyntaxError` will be thrown if the class contains more than one constructor method).
 
 ``` js
 class Person {

ebook/13_promises.md

@@ -126,13 +126,13 @@ myPromise
 
 We use `.then()` to grab the value when the promise resolves and `.catch()` when the promise rejects.
 
-If you see our error log you can see that it tells us where the error occured, that is because we wrote `reject(Error("this is our error"));` and not simply `reject("this is our error");`.
+Looking at our error log you can see that it tells us where the error occured, that is because we wrote `reject(Error("this is our error"));` and not simply `reject("this is our error");`.
 
  
 
 ### Chaining promises
 
-We can chain promises one after the other, using what was returned from the previous one as the base for the subsequent one, whether the promise resolved or got rejected.
+We can chain promises one after the other, using what was returned from the previous one as the base for the subsequent one, whether the promise was resolved or rejected.
 
 ``` js
 const myPromise = new Promise((resolve, reject) => {
@@ -251,7 +251,7 @@ Our values returned together, after 1000ms (the timeout of the *second* promise)
 
 If we were to pass an empty iterable then it will return an already resolved promise.
 
-If one of the promise was rejected, all of them would asynchronously reject with the value of that rejection, no matter if they resolved.
+If one of the promises was rejected, all of them would asynchronously reject with the value of that rejection, even if they resolved.
 
 ```js
 const promise1 =  new Promise((resolve,reject) => {
@@ -261,7 +261,7 @@ const promise2 =  new Promise((resolve,reject) => {
   reject(Error("oooops error"));
 });
 
-// one of the two promise will fail, but `.all` will return only a rejection.
+// one of the two promises will fail, but `.all` will return only a rejection.
 Promise
   .all([promise1, promise2])
   .then(data => {
@@ -274,7 +274,7 @@ Promise
   // Error: oooops error
 ```
 
-`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.
+`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 rejects, 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/14_generators.md

@@ -49,22 +49,22 @@ const fruitList = ['Banana','Apple','Orange','Melon','Cherry','Mango'];
 // create our looping generator
 function* loop(arr) {
   for (const item of arr) {
-    yield `I like to eat ${item}`;
+    yield `I like to eat ${item}s`;
   }
 }
 
 
 const fruitGenerator = loop(fruitList);
 fruitGenerator.next();
-// Object { value: "I like to eat Banana", done: false }
+// Object { value: "I like to eat Bananas", done: false }
 fruitGenerator.next();
-// Object { value: "I like to eat Apple", done: false }
+// Object { value: "I like to eat Apples", done: false }
 fruitGenerator.next().value;
-// "I like to eat Orange"
+// "I like to eat Oranges"
 ```
 
-- Our new generator will loop over the array and print one value at a time every time we call `.next()`.
-- if you are only concerned about getting the value, then use `.next().value` and it will not print the status of the generator
+- Our new generator will loop over the array and print one value at a time every time we call `.next()`
+- If you are only concerned about getting the value, then use `.next().value` and it will not print the status of the generator
 
  
 
@@ -113,21 +113,21 @@ myGenerator.throw("ooops");
 // Object { value: undefined, done: true }
 ```
 
-As you can see when we called `.throw()` the `generator` returned us the error and  finished even though we still had one more `yield` to execute.
+As you can see when we called `.throw()` the `generator` returned us the error and finished even though we still had one more `yield` to execute.
 
  
 
 ## Combining Generators with Promises
 
-As we have previously seen, Promises are very useful for asynchronous programming, and by combining them with generators we can have a very powerful tool at our disposal to avoid problems like the *callback hell*.
+As we have previously seen, Promises are very useful for asynchronous programming, and by combining them with generators we have a very powerful tool at our disposal to avoid problems like the *callback hell*.
 
-As we are solely discussing ES6, I won't be talking about async functions as they were introduce in ES2017 but know that the way they work is based on what you will see now.
+As we are solely discussing ES6, I won't be talking about async functions as they were introduced in ES2017, but know that the way they work is based on what you will see now.
 
 You can read more about async functions in Chapter 19.
 
-Using a Generator in combination with a `Promise` will allow us to write asynchronous code that feels like synchronous.
+Using a Generator in combination with a `Promise` will allow us to write asynchronous code that feels like synchronous code.
 
-What we want to do is to wait for a promise to resolve and then pass the resolved value back into our generator in the `.next()` call.
+What we want to do is wait for a promise to resolve and then pass the resolved value back into our generator in the `.next()` call.
 
 ``` js
 const myPromise = () => new Promise((resolve) => {
@@ -142,7 +142,7 @@ function* gen() {
   yield result + ' 2';
 };
 
-// Call the async function and pass params.
+// Call the async function and pass params
 const asyncFunc = gen();
 asyncFunc.next();
 // call the promise and wait for it to resolve

ebook/15_proxies.md

@@ -17,7 +17,7 @@ var x = new Proxy(target,handler)
 ```
 
 - our `target` can be anything, from an object, to a function, to another `Proxy`
-- a `handler` is an object which will define the behavior of our `Proxy` when an operation is performed on it.
+- a `handler` is an object which will define the behavior of our `Proxy` when an operation is performed on it
 
 ``` js
 // our object

ebook/16_sets_weaksets_maps_weakmaps.md

@@ -26,7 +26,7 @@ console.log(family);
 // Set [ "Dad", "Mom", "Son" ]
 ```
 
-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**.
+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 methods we can use on it.
 
@@ -49,7 +49,7 @@ family;
 
 As you can see a `Set` has a `size` property and we can `delete` an item from it or use `clear` to delete all the items from it.
 
-We can also notice that a `Set` does not have keys so when we call `.keys()` we get the same as calling `.values()` or `.entries()`.
+We can also notice that a `Set` does not have keys, so when we call `.keys()` we get the same result as calling `.values()` or `.entries()`.
 
  
 
@@ -137,7 +137,7 @@ As you can see after a few seconds **dad** was removed and *garbage collected*.
 
 ## What is a `Map`?
 
-A `Map` is similar to a `Set`, but they have key and value pairs.
+A `Map` is similar to a `Set`, but they have key/value pairs.
 
 ```js
 const family = new Map();

ebook/17_ES2016_incudes-and-exponential-operator.md

@@ -1,6 +1,6 @@
 # Chapter 17: Everything new in ES2016
 
-ES2016 introduced only two new features :
+ES2016 introduced only two new features:
 
 - `Array.prototype.includes()`
 - The exponential operator
@@ -24,7 +24,7 @@ array.includes(3);
 
 ### Combine `includes()` with `fromIndex`
 
-We can provide `.includes()` with an index where to begin searching for an element. Default is 0, but we can also pass a negative value.
+We can provide `.includes()` with an index to begin searching for an element. Default is 0, but we can also pass a negative value.
 
 The first value we pass in is the element to search and the second one is the index:
 
@@ -43,7 +43,7 @@ array.includes(11,-3);
 // true
 ```
 
-`array.includes(5,4);` returned `false` because, despite the array actually contains the number 5, it is found at the index 2 but we started looking at position 4. That's why we couldn't find it and it returned `false`.
+`array.includes(5,4);` returned `false` because, despite the array actually containing the number 5, it is found at the index 2 but we started looking at position 4. That's why we couldn't find it and it returned `false`.
 
 `array.includes(1,-1);` returned `false` because we started looking at the index -1 (which is the last element of the array) and then continued from that point onward.
 

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

@@ -1,6 +1,6 @@
 # Chapter 18: ES2017 string padding, `Object.entries()`, `Object.values()` and more
 
-ES2017 introduced many new cool features, which we are going to see here.
+ES2017 introduced many cool new features, which we are going to see here.
 
 ## String padding (`.padStart()` and `.padEnd()`)
 
@@ -13,8 +13,8 @@ We can now add some padding to our strings, either at the end (`.padEnd()`) or a
 // "hello "
 ```
 
-We specified that we want 6 as our padding, but why in both cases we got only 1 space?
-It happens because `padStart` and `padEnd` will go and fill the **empty spaces**. In our example "hello" is 5 letters, and our padding is 6, which leaves only 1 empty space.
+We specified that we want 6 as our padding, so then why in both cases did we only get 1 space?
+It happened because `padStart` and `padEnd` will go and fill the **empty spaces**. In our example "hello" is 5 letters, and our padding is 6, which leaves only 1 empty space.
 
 Look at this example:
 
@@ -85,7 +85,7 @@ family.father;
 "Jonathan Kent"
 ```
 
-`Object.keys()` returned us only the keys of the object that we then had to use to access the values.
+`Object.keys()` returned only the keys of the object that we then had to use to access the values.
 
 We now have two more ways of accessing our objects:
 
@@ -145,7 +145,7 @@ const object = {
 ```
 
 Notice how I wrote a comma at the end of the second property.
-It will not throw any error if you don't put it, but it's a better practice to follow as it will make the life easier to your colleague or team members.
+It will not throw any error if you don't put it, but it's a better practice to follow as it will make your colleague or team members life easier.
 
 ```js
 // I write

ebook/19_ES2017_async-and-await.md

@@ -109,7 +109,7 @@ Let's break down what we just did:
 - to create an `async` function we need to put the `async` keyword in front of it
 - the keyword will tell JavaScript to always return a promise
 - if we specify to `return <non-promise>` it will return a value wrapped inside a promise
-- the `await` keyword **only** works inside an `async` function.
+- the `await` keyword **only** works inside an `async` function
 - as the name implies, `await` will tell JavaScript to wait until the promise returns its result
 
 Let's see what happens if we try to use `await` outside an `async` function
@@ -153,7 +153,7 @@ asyncFunc();
 // TypeError: failed to fetch
 ```
 
-We use `try...catch` to grab the error, but in a case where  we do not have them we can still catch the error like this:
+We use `try...catch` to grab the error, but in a case where we do not have them we can still catch the error like this:
 
 ``` js
 async function asyncFunc(){