corrected spelling errors flagged by spell checker

remarcmij · remarcmij · commit cc390d420c46 · 2017-12-15T22:17:16.000+01:00
diff --git a/fundamentals/conditional_execution.md b/fundamentals/conditional_execution.md
@@ -37,7 +37,7 @@ if (distance < 10) {
 }
 ```
 
-A condition can take more complex forms, using `&&` (logival AND) and `||` (logical OR) operators:
+A condition can take more complex forms, using `&&` (logical AND) and `||` (logical OR) operators:
 
 ```js
 if (distance < 10 && !raining) {
@@ -70,16 +70,16 @@ if (distance < 10) {
     if (raining) {
         console.log('I will go public transportation.');
     } else {
-        console.log('I will walk.');        
+        console.log('I will walk.');
     }
 } else {
-    console.log('I will go by car.');    
+    console.log('I will go by car.');
 }
 ```
 
 > As (nested) `if` statements can become quite complex it is very important that you indent your source code so that there can be no confusion about which statement blocks are executed for each condition, as was done in the examples.
 
->More informaton on MDN: [if...else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
+>More information on MDN: [if...else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
 
 ## The conditional (ternary) operator
 
@@ -91,7 +91,7 @@ The general format is:
 condition ? expr1 : expr2
 ```
 
-('ternary' means: _composed of three parts_) 
+('ternary' means: _composed of three parts_)
 
 It is often used in combination with an assignment, as in this example:
 
@@ -108,7 +108,7 @@ It is **not** recommended to use the conditional operator if you do not intend t
 age < 1 ? console.log('new') : console.log('used');
 ```
 
->More informaton on MDN: [Conditional (ternary) Operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator)
+>More information on MDN: [Conditional (ternary) Operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator)
 
 ## The switch statement
 
@@ -151,11 +151,11 @@ Depending on the value of the expression specified in the `switch` clause, one o
 
 The `default` statement at the end is executed when none of the preceding cases hold true. The `default` statement is not strictly required, but is a best practice to always specify one.
 
->More informaton on MDN: [switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
+>More information on MDN: [switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
 
 ## truthy, falsy
 
-**truthy**: 'sort of' `true`  
+**truthy**: 'sort of' `true`
 **falsy**: 'sort of' `false`
 
 From MDN:
@@ -182,4 +182,4 @@ if (x) {
 }
 ```
 
->More informaton on MDN: [Truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), [Falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy)
+>More information on MDN: [Truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), [Falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy)
diff --git a/fundamentals/javascript_review.md b/fundamentals/javascript_review.md
@@ -2,14 +2,14 @@
 
 You'll need to know the following before starting the Node class (remember Node is just JavaScript in a different environment - and you KNOW JS already - right?!?!)
 
-``` 
+```
 From Jason:
-jason [9:11 AM] 
+jason [9:11 AM]
 @timirkaria the most important topics will be sync/async and ajax. That and basic syntax (named and anonymous functions, callbacks, scope) should be sufficient!
 ```
 
 ### AJAX
-Stands for *A*syncrhonous *J*avascript *A*nd *X*ml (think of XML as the old JSON) but now it's AJA*J* but that doesn't sound as good. 
+Stands for *A*synchronous *J*avascript *A*nd *X*ml (think of XML as the old JSON) but now it's AJA*J* but that doesn't sound as good.
 
 So here's an example of a SYNCHRONOUS request (it waits for the request to come back before continuing)
 
@@ -29,7 +29,7 @@ console.log('Made the request')
 
 ```
 
-And here's an example of an ASYNCHRONOUS version of the same request as above. Look carefully at the output. 
+And here's an example of an ASYNCHRONOUS version of the same request as above. Look carefully at the output.
 
 ```js
 var SECRET_MESSAGE_URL = 'https://gist.githubusercontent.com/tkaria/08325583e7411f7de6b80871780fd917/raw/61dae2869ae5013652bbeba1da2487097d8869b1/SecretMessage.txt'
@@ -52,16 +52,16 @@ xhr.send(null);
 console.log('Made the request');
 ```
 
-### What's happening here? 
+### What's happening here?
 As always - read the docs first...
-`https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest` 
+`https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest`
 
 Create a new request and open it (lines 2 and 3)
-Tell the request object what function to call when when the contents of the request are loaded. Inside the ANONYMOUS function which takes a parameter `e` we check the response code from the request (this is just HTTP stuff - nothing special). If the reponse code is good (200) then we print what we got. 
+Tell the request object what function to call when when the contents of the request are loaded. Inside the ANONYMOUS function which takes a parameter `e` we check the response code from the request (this is just HTTP stuff - nothing special). If the response code is good (200) then we print what we got.
 
-More interesting is the order of the print statements. In the first example we saw the message `Received the response` **BEFORE** we saw the `Made the request` message because the program waited to get the response and print it before continuing to run. 
+More interesting is the order of the print statements. In the first example we saw the message `Received the response` **BEFORE** we saw the `Made the request` message because the program waited to get the response and print it before continuing to run.
 
-In this case we see the `Made the request` message before we see the response because the program keeps running while waiting for the response. When the response is finally received it is printed before writing the `Received the response` to the console. 
+In this case we see the `Made the request` message before we see the response because the program keeps running while waiting for the response. When the response is finally received it is printed before writing the `Received the response` to the console.
 
 Note that we used an anonymous function here - it has no name. There's nothing special about an anonymous function. We could equally use a named function in the above example:
 
@@ -80,7 +80,7 @@ function NOT_ANONYMOUS_ON_LOAD_FUNCTION(parameter) {
   }
 }
 xhr.open("GET", SECRET_MESSAGE_URL, true);
-xhr.onload = NOT_ANONYMOUS_ON_LOAD_FUNCTION; // Note: we are not CALLING the function - there are no () 
+xhr.onload = NOT_ANONYMOUS_ON_LOAD_FUNCTION; // Note: we are not CALLING the function - there are no ()
 // We'll leave the error function the way it is and you can change it to a named function
 xhr.onerror = function (e) {
   console.error(xhr.statusText);
@@ -90,14 +90,14 @@ console.log('Made the request');
 
 ```
 
-### The big idea: 
+### The big idea:
 
-#### Sync / Async 
-Make requests without waiting for the response and just get "notified" when the response happens. That's the asyncrhonous part - don't wait for it and stop everything else just let me know when it happens. How can the computer let you know? You tell it what to do when the async function is ready (has something to say - success or failure) 
+#### Sync / Async
+Make requests without waiting for the response and just get "notified" when the response happens. That's the asynchronous part - don't wait for it and stop everything else just let me know when it happens. How can the computer let you know? You tell it what to do when the async function is ready (has something to say - success or failure)
 
 #### Named and anonymous functions
-Some functions have names and some don't. Sometimes you just want to use a function to pass it to another function so you don't need to name it. It never needs to be called outside of the function that you're passing it to so it doesn't need a name. 
-The simplest asynchonous function that you will see all over the place is called `setTimeout` (right now you should be reaching for a new tab and typing `MDN setTimeout` into Google). Be patient when running the below - it takes 3 seconds...
+Some functions have names and some don't. Sometimes you just want to use a function to pass it to another function so you don't need to name it. It never needs to be called outside of the function that you're passing it to so it doesn't need a name.
+The simplest asynchronous function that you will see all over the place is called `setTimeout` (right now you should be reaching for a new tab and typing `MDN setTimeout` into Google). Be patient when running the below - it takes 3 seconds...
 
 For example (using a named function):
 ```js
@@ -130,20 +130,20 @@ console.log('After timeoutFunction');
 What to do when the result of an async request is returned. Remember that requests can succeed as well as fail. Plan for (AND TEST) both.
 
 #### Scope
-I think we covered this pretty well with our discussion of closures in the last class but let me know if you need more. 
+I think we covered this pretty well with our discussion of closures in the last class but let me know if you need more.
 
 ## Recap
-Read this - you may not understand it all but please read it before you read anything else about closures. The reason is that this is source material - this is the primary documentation. It is written very technically and in a bit of a boring way but there's a reason (as we talked about in class). The reason is to be clear so the language is precise and technical. It's OK if you don't get it now but just read it and it will stay in the back of your head. 
+Read this - you may not understand it all but please read it before you read anything else about closures. The reason is that this is source material - this is the primary documentation. It is written very technically and in a bit of a boring way but there's a reason (as we talked about in class). The reason is to be clear so the language is precise and technical. It's OK if you don't get it now but just read it and it will stay in the back of your head.
 https://developer.mozilla.org/en/docs/Web/JavaScript/Closures
 
-Please TYPE these exercises - do NOT copy and paste.  BEFORE you run them please make a guess in your head about what will happen. 
+Please TYPE these exercises - do NOT copy and paste.  BEFORE you run them please make a guess in your head about what will happen.
 ```js
 function init() {
   var name = 'Mozilla'; // name is a local variable created by init
   function displayName() { // displayName() is the inner function, a closure
-    alert(name); // use variable declared in the parent function    
+    alert(name); // use variable declared in the parent function
   }
-  displayName();    
+  displayName();
 }
 init();
 ```
@@ -152,18 +152,18 @@ init();
 function init() {
   var name = 'Mozilla'; // name is a local variable created by init
   function displayName() { // displayName() is the inner function, a closure
-    alert(name); // use variable declared in the parent function    
+    alert(name); // use variable declared in the parent function
   }
 }
-displayName();    
+displayName();
 ```
 
 ```js
 var name = 'Hack your future'
 function init() {
   var name = 'Mozilla'; // name is a local variable created by init
   function displayName() { // displayName() is the inner function, a closure
-    alert(name); // use variable declared in the parent function    
+    alert(name); // use variable declared in the parent function
   }
   displayName();
 }
@@ -174,37 +174,37 @@ init();
 var name = 'Hack your future'
 function init(name) {
   function displayName(name) { // displayName() is the inner function, a closure
-    alert(name); // use variable declared in the parent function    
+    alert(name); // use variable declared in the parent function
   }
   displayName(name);
 }
 init('Hack your future again')
 ```
 
-Now read this: http://stackoverflow.com/questions/11488014/asynchronous-process-inside-a-javascript-for-loop 
+Now read this: http://stackoverflow.com/questions/11488014/asynchronous-process-inside-a-javascript-for-loop
 
-And try out the examples - please make SURE you understand what is happening. Ask questions if you do not. 
+And try out the examples - please make SURE you understand what is happening. Ask questions if you do not.
 
 Same instructions as above but now for Arrow functions (remember this is not intended to confuse you - it's just code).
 
 ### Arrow functions
 https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions
-Then read this. 
+Then read this.
 http://stackoverflow.com/questions/22939130/when-should-i-use-arrow-functions-in-ecmascript-6/28135120#28135120
 
-This is a normal function: 
+This is a normal function:
 ```js
 function sayHello(name) {
     return 'Hello ' + name;
 }
 ```
 
-Same as above with arrow (fat arrow) notation - shorthand notation. This is easy to mess up. Notice no return. 
+Same as above with arrow (fat arrow) notation - shorthand notation. This is easy to mess up. Notice no return.
 ```js
 var sayHello2 = (name) => 'Hello ' + name;
 ```
 
-Same as above with arrow (fat arrow) notation - shorthand notation.  Better - easier to read - with return. 
+Same as above with arrow (fat arrow) notation - shorthand notation.  Better - easier to read - with return.
 ```js
 var sayHello2 = (name) => {return 'Hello ' + name;}
 ```
@@ -216,7 +216,7 @@ function Person(firstName) {
 }
 ```
 
-Looks the same but what happens? See if you can figure out why from reading the documentation. 
+Looks the same but what happens? See if you can figure out why from reading the documentation.
 ```js
 var Person = (firstName) => {this.firstName = firstName}
 ```
@@ -232,7 +232,7 @@ for (i = 0; i < 3; i++) {
 }
 ```
 
-### Make the above function do what we think it should do. 
+### Make the above function do what we think it should do.
 
 ### Return examples
 ```js
@@ -247,7 +247,7 @@ function f2(x) {
 }
 ```
 
-### Static members 
+### Static members
 http://odetocode.com/blogs/scott/archive/2015/02/02/static-members-in-es6.aspx
 
 ### Closures examples
@@ -256,7 +256,7 @@ https://jsfiddle.net/78dg25ax/?utm_source=website&utm_medium=embed&utm_campaign=
 ### Why closures are helpful with async code:
 http://stackoverflow.com/questions/13343340/calling-an-asynchronous-function-within-a-for-loop-in-javascript
 
-### Promises 
+### Promises
 http://stackoverflow.com/questions/13343340/calling-an-asynchronous-function-within-a-for-loop-in-javascript
 https://www.youtube.com/watch?v=WBupia9oidU
 
diff --git a/fundamentals/loops.md b/fundamentals/loops.md
@@ -2,7 +2,7 @@
 
 A loop is a programming construct to perform a repetitive action. Often (but not always) the repetitive action involves accessing or manipulating the individual elements of an array.
 
-We will use the array of month names given below to illustrate the various types of loop constructs available in JavaScript. In the examples we will print out the names of the invidual months using a `console.log` statement.
+We will use the array of month names given below to illustrate the various types of loop constructs available in JavaScript. In the examples we will print out the names of the individual months using a `console.log` statement.
 
 ```js
 const months = [
diff --git a/fundamentals/map_filter.md b/fundamentals/map_filter.md
@@ -120,7 +120,7 @@ The key to understanding the **reduce()** method is in the line:
 accumulator = reducerFn(accumulator, this[i], i, this);
 ```
 
-In the case we don't need the current loop index and the subject array in the reducer function (which is oftent the case), we can simplify this to:
+In the case we don't need the current loop index and the subject array in the reducer function (which is often the case), we can simplify this to:
 
 ```js
 accumulator = reducerFn(accumulator, this[i]);
diff --git a/fundamentals/promises.md b/fundamentals/promises.md
diff --git a/fundamentals/scope.md b/fundamentals/scope.md
