Fixed typos

Author: Sean Arseneault

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