fix typos in post 13-20

Author: AlbertoMontalesi

.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+  "cSpell.enabled": false,
+  "spellright.language": "English (American)",
+  "spellright.documentTypes": [
+    "markdown",
+    "latex",
+    "plaintext"
+  ]
+}

ebook/03_default_function_arguments.md

@@ -30,7 +30,7 @@ It works, but it's not very nice, how to improve it?
 With **destructuring** we can write this:
 
 ``` javascript
-const Bill = calculatePrice({ tip: 0.15, total:150});
+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.

ebook/13_promises.md

@@ -48,7 +48,6 @@ 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.
@@ -227,12 +226,12 @@ promise1.then(data => {
   console.log(data);
 });
 // after 500 ms
-// my first value
+// first value
 promise2.then(data => {
   console.log(data);
 });
 // after 1000 ms
-// my second value 
+// second value
 ```
 
 They will resolve independently from one another but look at what happens when we use `Promise.all().`
@@ -245,10 +244,10 @@ Promise
     console.log(promise1data, promise2data);
   });
 // after 1000 ms
-// my first value my second value
+// first value second value
 ```
 
-Our values returned together, after 1000ms (the timeout of the *second* promise) meanin 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 the completion of the second one.
 
 If we were to pass an empty iterable then it will return an already resolved promise.
 

ebook/14_generators.md

@@ -1,6 +1,6 @@
 # Chapter 14: Generators
 
-## What is a Generator ?
+## What is a Generator?
 
 A generator function is a function that we can start and stop, for an indefinite amount of time, and restart with the possibility of passing additional data at a later point in time.
 
@@ -66,7 +66,7 @@ fruitGenerator.next().value;
 ```
 
 - 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
+- if you are only concerned about getting the value, then use `.next().value` and it will not print the status of the generator
 
  
 
@@ -120,12 +120,13 @@ As you can see when we called `.throw()` the `generator` returned us the error a
 
  
 
-
 ## 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 can 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 ES8 (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 introduce in ES8 (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.
 
@@ -148,8 +149,9 @@ function* gen() {
 const asyncFunc = gen();
 asyncFunc.next();
 // call the promise and wait for it to resolve
+// {value: Promise, done: false}
 asyncFunc.next();
 // Object { value: "our value is... 2", done: false }
 ```
 
-The first time we call `.next()` it will call our promise and wait for it to resolve( in our simple example it resolves immediately) and when we call `.next()` again it will utilize the value returned by the promise to do something else(in this case just interpolate a string).
+The first time we call `.next()` it will call our promise and wait for it to resolve (in our simple example it resolves immediately) and when we call `.next()` again it will utilize the value returned by the promise to do something else (in this case just interpolate a string).

ebook/15_proxies.md

@@ -8,16 +8,16 @@ From MDN:
 
  
 
-## How to use a Proxy ?
+## How to use a `Proxy` ?
 
 This is how we create a Proxy:
 
 ``` js
 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
+- 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
 
 ``` js
 // our object
@@ -47,6 +47,6 @@ When we call the `get` method we step inside the normal flow and change the valu
 
 When setting a new value we step in again and log a short message before setting the value.
 
-Proxies can be very useful for example if your object is a phone number.
+Proxies can be very useful, for example if your object is a phone number.
 
 You can take the value given by the user and format it to match the standard formatting of your country.

ebook/16_sets_weaksets_maps_weakmaps.md

@@ -26,9 +26,9 @@ 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 methd we can use on it.
+Let's continue using the same `Set` and see what method we can use on it.
 
 ``` js
 family.size;
@@ -95,14 +95,14 @@ console.log(uniqueArray);
 
 // write the same but in a single line
 const uniqueArray = Array.from(new Set(myArray));
-// // Array [ "dad", "mom", "son", "daughter" ]
+// Array [ "dad", "mom", "son", "daughter" ]
 ```
 
 As you can see the new array only contains the unique values from the original array.
 
  
 
-## What is a `WeakSet` ?
+## What is a `WeakSet`?
 
 A `WeakSet` is similar to a `Set` but it can **only** contain Objects.
 
@@ -138,9 +138,9 @@ As you can see after a few seconds **dad** was removed and *garbage collected*.
 
  
 
-## What is a `Map` ?
+## 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 and value pairs.
 
 ```js
 const family = new Map();
@@ -167,14 +167,13 @@ for(const [key,val] of family){
 // Son 20
 ```
 
-If you remember, we could iterate over a `Set` only with a `for of` loop while we can iterate over a `Map` with both a `for of` and a `forEach` loop.
-
+If you remember, we could iterate over a `Set` only with a `for of` loop, while we can iterate over a `Map` with both a `for of` and a `forEach` loop.
 
  
 
-## What is a `WeakMap` ?
+## What is a `WeakMap`?
 
-A `WeakMap` is a collection of key/value pairs and similarly to a `WeakSet`, even in a `WeakMap` the keys are *weakly* referenced, which means that when the reference is lost the value will be removed from the `WeakMap` and *garbage collected*.
+A `WeakMap` is a collection of key/value pairs and similarly to a `WeakSet`, even in a `WeakMap` the keys are *weakly* referenced, which means that when the reference is lost, the value will be removed from the `WeakMap` and *garbage collected*.
 
 A `WeakMap` is **not** enumerable therefore we cannot loop over it.
 

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

@@ -1,11 +1,9 @@
 # Chapter 17: Everything new in ES2016 (ES7)
 
-
-
 ES2016 introduced only two new features :
 
 - `Array.prototype.includes()`
-- the exponential operator
+- The exponential operator
 
  
 
@@ -21,13 +19,14 @@ array.includes(2);
 array.includes(3);
 // false
 ```
+
  
 
 ### 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.
 
-The first value we pass is the element to search and the second one is the index:
+The first value we pass in is the element to search and the second one is the index:
 
 ``` js
 let array = [1,3,5,7,9,11];
@@ -42,9 +41,9 @@ array.includes(11,-3);
 // true
 ```
 
-`array.includes(5,4);` returned `false` because, despite the array actually contains the number 5, it is 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 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(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 onwards.
+`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.
 
 `array.includes(11,-3);` returned `true` because we went back to the index -3 and moved up, finding the value 11 on our path.
 

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

@@ -4,7 +4,7 @@ ES2017 introduced many new cool features, which we are going to see here. I will
 
 ## String padding(`padStart` and `padEnd`)
 
-We can now add some padding to our strings, either at the end (`padEnd`) or at the beginning (`padStart`).
+We can now add some padding to our strings, either at the end (`padEnd`) or at the beginning (`padStart`) of them.
 
 ```js
 "hello".padStart(6);
@@ -13,10 +13,10 @@ We can now add some padding to our strings, either at the end (`padEnd`) or at t
 // "hello "
 ```
 
-We said 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, 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.
 
-Look at this example
+Look at this example:
 
 ```js
 "hi".padStart(10);
@@ -36,7 +36,8 @@ We can use `padStart` if we want to right align something.
 ```js
 const strings = ["short", "medium length", "very long string"];
 
-const longestString = strings.sort(str => str.length).map(str => str.length)[0];
+const longestString = strings.sort(str => str.length)
+                              .map(str => str.length)[0];
 
 strings.forEach(str => console.log(str.padStart(longestString)));
 
@@ -80,7 +81,7 @@ In previous versions of JavaScript we would have accessed the values inside the
 
 ```js
 Object.keys(family);
-// (3) ["father", "mother", "son"]
+// ["father", "mother", "son"]
 family.father;
 "Jonathan Kent"
 ```
@@ -91,12 +92,12 @@ We now have two more ways of accessing our objects:
 
 ```js
 Object.values(family);
-// (3) ["Jonathan Kent", "Martha Kent", "Clark Kent"]
+// ["Jonathan Kent", "Martha Kent", "Clark Kent"]
 
 Object.entries(family);
-// (2) ["father", "Jonathan Kent"]
-// (2) ["mother", "Martha Kent"]
-// (2) ["son", "Clark Kent"]
+// ["father", "Jonathan Kent"]
+// ["mother", "Martha Kent"]
+// ["son", "Clark Kent"]
 ```
 
 `Object.values()` returns an array of all the values whilst `Object.entries()` returns an array of arrays containing both keys and values.
@@ -145,7 +146,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 the life easier to your colleague or team members.
 
 ```js
 // I write
@@ -160,7 +161,7 @@ const object = {
   prop2: "propop"
   prop3: "propopop"
 }
-// suddenly he gets an error because he did not notice that I forgot to leave a comma at the end of the last parameter.
+// suddenly, he gets an error because he did not notice that I forgot to leave a comma at the end of the last parameter.
 ```
 
 

ebook/19_ES8_async-and-await.md

@@ -14,15 +14,15 @@ fetch('api.github.com/user/AlbertoMontalesi').then( res => {
   // return the data in json format
   return res.json();
 }).then(res => {
-  // if everything went well, log the data
+  // if everything went well, print the data
   console.log(res);
 }).catch( err => {
-  // or log the error
+  // or print the error
   console.log(err);
 })
 ```
 
-This is a very simple promise to fetch a user from github and print it to the console.
+This is a very simple promise to fetch a user from GitHub and print it to the console.
 
 Let's see a different example:
 
@@ -61,7 +61,7 @@ walk(1000).then(res => {
 // you walked for 700ms 
 // you walked for 800ms 
 // uncaught exception: the value is too small
-``` 
+```
 
 Let's see how we can rewrite this `Promise` with the new async/await syntax.
 
@@ -81,7 +81,7 @@ function walk(amount) {
 
 // create an async function
 async function go() {
-  // use the keyword await to wait for the response
+  // use the keyword `await` to wait for the response
   const res = await walk(500);
   console.log(res);
   const res2 = await walk(900);
@@ -110,13 +110,13 @@ 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
 
 ```js
-// use async inside a normal function
+// use await inside a normal function
 function func() {
   let promise = Promise.resolve(1);
   let result = await promise; 
@@ -125,13 +125,13 @@ func();
 // SyntaxError: await is only valid in async functions and async generators
 
 
-// use async in the top-level code
+// use await in the top-level code
 let response = Promise.resolve("hi");
 let result = await response;
 // SyntaxError: await is only valid in async functions and async generators
 ```
 
-> *Remember*: you can only use `await` inside an `async` function.
+> **Remember** that you can only use `await` inside an `async` function.
 
 &nbsp;
 
@@ -145,16 +145,16 @@ async function asyncFunc() {
 
   try {
     let response = await fetch('http:your-url');
-  } catch(err) {
-    }
-    console.log(err); 
+    } catch(err) {
+        console.log(err);
+      }
 }
 
 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