updated review week1

mkruijt · mkruijt · commit 8f769b941125 · 2017-08-30T14:38:21.000+02:00
diff --git a/Week0/README.md b/Week0/README.md
@@ -6,6 +6,7 @@ In week one we will discuss the following topics:
 • Intro JavaScript (What is it, where can you use it for)
 • Variables [var, let, const]
 • Basic Data types [Strings, Numbers, Arrays]
+• Operators
 ```
 
 ### Here are resources that we like you to read as a preparation for the coming lecture:
diff --git a/Week1/README.md b/Week1/README.md
@@ -14,6 +14,8 @@ In week two we will discuss the following topics:
 
 - 'Functions' of _A Smarter Way To Learn JavaScript_ : Chapters 35 - 38
 - Functions ~ http://eloquentjavascript.net/03_functions.html
+- 'Objects' of _A Smarter Way To Learn JavaScript_ : Chapters 35 - 38
+- 'Conditions' of _A Smarter Way To Learn JavaScript_ : Chapters 35 - 38
 - Program structure ~ http://eloquentjavascript.net/02_program_structure.html
 
 _Please go through the material and come to class prepared!_
diff --git a/Week1/REVIEW.md b/Week1/REVIEW.md
@@ -1,5 +1,14 @@
 # REVIEW JavaScript Basics week 1
 
+```
+This review covers:
+• some commands thought by Unmesh in class today :white_check_mark: 
+• Intro JavaScript (What is it, where can you use it for)
+• Variables [var, let, const] :white_check_mark: 
+• Basic Data types [Strings, Numbers, Arrays] :white_check_mark: 
+• Operators
+```
+
 ## CLI
 ```
 pwd : present working directory
@@ -33,6 +42,12 @@ man <COMMAND> : Display manual of the COMMAND
 
 A "variable" is a place where you can store information, such as a string, or a number. New variables in JavaScript are declared using one of three keywords: let, const, or var.
 
+> Think of variables names like **labels** on boxes, while the value of the variable are the **contents** of the box - you could change the contents of a box and leave the label intact, the contents of the boxes can have different types, the boxes should have good labels (a box of books being labeled pens would be very confusing),
+>
+![Variables are like boxes](./assets/box.png)
+> Photo from [Khan Academy](http://cs-blog.khanacademy.org/2013/09/teaching-variables-analogies-and.html)
+
+
 ### Variable declaration
 
 Variables are "declared" using the `var`, `let` or `const` keyword:
@@ -62,8 +77,6 @@ foo = 4;  // change variable `foo`
 ```
 
 
-Basic Data types [Strings, Numbers, Arrays]
-
 ## Variable types
 
 All variables have a type. In our example above, the variable `x` is a `number`. JavaScript supports the following types:
@@ -105,6 +118,13 @@ let x;
 console.log(typeof x); // -> "undefined"
 ```
 
+## Strings
+
+>TODO
+
+## Numbers
+
+>TODO
 
 ## Arrays
 
@@ -131,14 +151,84 @@ console.log(arr[a]); // -> jane
 
 If the index you use is not an integer (a whole number), or if it's less than `0` or if it's greater than or equal to the array's length, you will get back `undefined`.
 
+More about [arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
 
-### 2.3 Basic operators
+### Comparison operators
 
 >Note the two different uses of the equals sign:
 A single equals sign (=) is used to assign a value to a variable.
 A triple equals sign (===) is used to compare two values (see Equality Operators).
 
-### 2.5 Operator precedence
+#### Equality operators
+* Equality `==`
+* Inequality `!=`
+* Identity / strict equality `===`
+* Non-identity / strict inequality `!==`
+
+How does this work in practice?
+
+```js
+1 == 1 // true
+7 == '7' // true
+1 != 2  // true
+5 === 5   // true
+9 === '9'   // false
+3 !== 3 // true
+3 !== '3' // true
+```
+
+> why does `7 == '7'` returns true and `9 === '9'` returns false?
+
+#### Relational operators
+* Greater than operator `>`
+* Greater than or equal operator `>=`
+* Less than operator `<`
+* Less than or equal operator `<=`
+
+```js 
+4 > 3   // returns true
+3 >= 3  // returns true
+13 < 12 //returns false
+3 <= 4   // returns true
+```
+
+More about [comparison operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators)
+
+### Arithmetic operators
+
+* Addition `+`
+* Subtraction `-`
+* Multiplication `*`
+* Division `/`       
+* Remainder (sometimes called modulo) `%`   
+<br>Returns the remainder left over after you've shared the left number out into a number of integer portions equal to the right number.
+
+```js
+8 + 9 //returns 17, adds two numbers together.  
+20 - 12 //returns 8, subtracts the right number from the left.
+3 * 4 //returns 12, multiplies two numbers together.
+10 / 5 //return 2, divides the left number by the right.   
+8 % 3 //returns 2, as three goes into 8 twice, leaving 2 left over.
+```
+
+More about [Arithmetic_Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#.25_.28Modulus.29)
+
+### Logical operators
+
+* AND `&&`
+* OR `||` 
+* NOT `!`
+
+Given that x = 6 and y = 3
+```js
+x < 10 && y > 1 // returns true
+x == 5 || y == 5 // returns false
+x !== y // returns true
+```
+
+More about [logical operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators)
+
+### Operator precedence
 
 There are compound assignment operators such as +=. The following two assignments are equivalent:
 
diff --git a/Week1/assets/box.png b/Week1/assets/box.png
diff --git a/Week2/MAKEME.md b/Week2/MAKEME.md
@@ -90,7 +90,7 @@ More insights from this [Stack Overflow question](http://stackoverflow.com/quest
 
 ### Step 2: **Some freeCodeCamp challenges:**
 
-1.. [Comparisons with the Logical And Operator](https://www.freecodecamp.com/challenges/comparisons-with-the-logical-and-operator)
+1. [Comparisons with the Logical And Operator](https://www.freecodecamp.com/challenges/comparisons-with-the-logical-and-operator)
 
 2. [Record Collection](https://www.freecodecamp.com/challenges/record-collection)
 
diff --git a/Week2/REVIEW.md b/Week2/REVIEW.md
@@ -1,72 +1,15 @@
 # REVIEW JavaScript week 2
 
-## Statements & expressions
-
-Most programming languages that you'll encounter in real life are called "imperative" programming languages. JavaScript is such an imperative programming language. Imperative is another word for command-like. That is, you give the computer a bunch of commands after each other. First do this, then do that, etc.
-
-These individual commands are called "statements" in imperative programming languages. You can compare them with sentences in the English language. They have a use by themselves, and do not need something else. "The man eats bread." is a full sentence, it conveys a meaning by itself. A sentence in English is always terminated by a period.
-
-Similarly, a statement in JavaScript should provide a command by itself. JavaScript-statements are (almost always) terminated by a semicolon.
-
-This is a complete statement:
-
-```js
-let s = "HackYourFuture";
-```
-
-It is a full command: declare a variable `s` and initialize it with `"HackYourFuture"`. JavaScript doesn't need any other information to know what we want. The statement is terminated with a semicolon.
-
-However, this is not a complete statement:
-
-```js
-4 + 5
-```
-
-This equals `9`, but what is JavaScript to do with it? It doesn't provide a command. You'd need to do something with it, e.g. `var x = 4 + 5;` or `callFunction(4 + 5)`. We call these parts of statements "expressions". Expressions are not terminated by semicolons. Expressions always "evaluate into a value". In our example, the expression `4 + 5` "evaluates into `9`". If expressions cannot be evaluated into a value, they are invalid. For instance, `4 +` is not a valid expression, it is incomplete, because we need something else after the plus sign.
-
-So, statements can *contain* expressions. Can expressions contain statements? No, they cannot. However, they can themselves contain expressions. Think about `4 + 5`: it contains the expressions `4` and `5`, as these both evaluate into a value: the expression `4` evaluates into the number `4`, it is a very simple expression. Similarly, `true`, `null`, `undefined` are all expressions.
-
-### Examples of expressions
-
-Here are some examples of expressions. Remember: expressions evaluate into a value, but do not provide a command:
-
-* `sum(a, b)`
-* `a`
-* `a > 4 ? "yes" : "no"`
-* `a + b`
-* `a && b || c`
-* `arr.length`
-* `obj["name"]`
-* `[1, 2, 3]`
-* `arr[1]`
-* `[1]` (this is an array with one element!)
-* `function a() { return 4; }`
-
-The last one requires a bit of explanation. If you write:
-
-```js
-function a() { return 4; }
 ```
-
-by itself, this is a *statement* (a function declaration statement). However, if you write it as part of a statement, such as:
-
-```js
-let b = function a() { return 4; }
+This review covers:
+• Loops (for/while)
+• Functions :white_check_mark: 
+• Advanced data types [Objects] :white_check_mark: 
+• Conditions
+• Statements vs Expressions :white_check_mark: 
+• Naming conventions
 ```
 
-now it is an expression. This is an exceptional situation where something can be a statement or an expression.
-
-### Examples of not-expressions
-
-The following are not expressions:
-
-* `var` -> this is a keyword, see below
-* `var x;` -> this is a statement
-* `+` -> this is only an operator
-* `if (a > 4) { return "yes"; } else { return "no"; }`
-
-`if` is also a statement. However, it is quite a complex statement. It is also referred to as a "construct", just like `for`, `while`, `try`, etc.
-
 ## Functions
 
 A function is a reusable piece of code. Functions are *very* important in JavaScript, to the extent that some people call JavaScript a "function-oriented" language. As mentioned above, variables can be of type function. In fact, *every function is a variable*.
@@ -144,3 +87,104 @@ myArray.slice();
 myNumber.toString();
 ...
 ```
+
+
+## Objects
+
+Variables that are objects also contain a list of things, but instead of them being in some specific order, they can be assigned to words, called "keys". Instead of "elements" the things that are inside objects are called "properties".
+
+
+```js
+var obj = {name: 'John', age: 24};
+```
+
+This object has two properties: `name` and `age`. The "value" of the property `name` is the string `'John'`. The "value" of the property `age` is the number `24`.
+
+When accessing object properties, you can use the dot-notation: `obj.name` or the bracket-notation: `obj["name"]`. Note that the latter looks a lot like the way to access array elements. However, here what's inside the bracket (called "key" for objects, instead of "index") must be a string.
+
+```js
+console.log(obj.name); // -> 'John'
+console.log(obj['name']); // -> 'John'
+```
+
+Just like with arrays, you can also use a variable to access properties, as long as these variables are strings. In this case you cannot use the dot-notation!
+
+```js
+var ageKey = 'age';
+console.log(obj[ageKey]); // -> 24
+```
+
+Remember that there is a very big difference between `obj[name]` and `obj["name"]`.
+
+> Note:
+>
+> Thinking back of arrays, the length of an array can be retrieved by `arr.length`. So as mentioned before, arrays are just like other JavaScript objects. You could even write `arr['length']` to access the `length` property of the array. JavaScript will look: is what we put between brackets a number? Then it is an index and we'll look up the correct array element. If it's a string, it's a key and we will look up the corresponding property.
+
+
+## Statements & expressions
+
+Most programming languages that you'll encounter in real life are called "imperative" programming languages. JavaScript is such an imperative programming language. Imperative is another word for command-like. That is, you give the computer a bunch of commands after each other. First do this, then do that, etc.
+
+These individual commands are called "statements" in imperative programming languages. You can compare them with sentences in the English language. They have a use by themselves, and do not need something else. "The man eats bread." is a full sentence, it conveys a meaning by itself. A sentence in English is always terminated by a period.
+
+Similarly, a statement in JavaScript should provide a command by itself. JavaScript-statements are (almost always) terminated by a semicolon.
+
+This is a complete statement:
+
+```js
+let s = "HackYourFuture";
+```
+
+It is a full command: declare a variable `s` and initialize it with `"HackYourFuture"`. JavaScript doesn't need any other information to know what we want. The statement is terminated with a semicolon.
+
+However, this is not a complete statement:
+
+```js
+4 + 5
+```
+
+This equals `9`, but what is JavaScript to do with it? It doesn't provide a command. You'd need to do something with it, e.g. `var x = 4 + 5;` or `callFunction(4 + 5)`. We call these parts of statements "expressions". Expressions are not terminated by semicolons. Expressions always "evaluate into a value". In our example, the expression `4 + 5` "evaluates into `9`". If expressions cannot be evaluated into a value, they are invalid. For instance, `4 +` is not a valid expression, it is incomplete, because we need something else after the plus sign.
+
+So, statements can *contain* expressions. Can expressions contain statements? No, they cannot. However, they can themselves contain expressions. Think about `4 + 5`: it contains the expressions `4` and `5`, as these both evaluate into a value: the expression `4` evaluates into the number `4`, it is a very simple expression. Similarly, `true`, `null`, `undefined` are all expressions.
+
+### Examples of expressions
+
+Here are some examples of expressions. Remember: expressions evaluate into a value, but do not provide a command:
+
+* `sum(a, b)`
+* `a`
+* `a > 4 ? "yes" : "no"`
+* `a + b`
+* `a && b || c`
+* `arr.length`
+* `obj["name"]`
+* `[1, 2, 3]`
+* `arr[1]`
+* `[1]` (this is an array with one element!)
+* `function a() { return 4; }`
+
+The last one requires a bit of explanation. If you write:
+
+```js
+function a() { return 4; }
+```
+
+by itself, this is a *statement* (a function declaration statement). However, if you write it as part of a statement, such as:
+
+```js
+let b = function a() { return 4; }
+```
+
+now it is an expression. This is an exceptional situation where something can be a statement or an expression.
+
+### Examples of not-expressions
+
+The following are not expressions:
+
+* `var` -> this is a keyword, see below
+* `var x;` -> this is a statement
+* `+` -> this is only an operator
+* `if (a > 4) { return "yes"; } else { return "no"; }`
+
+`if` is also a statement. However, it is quite a complex statement. It is also referred to as a "construct", just like `for`, `while`, `try`, etc.
+
diff --git a/Week3/REVIEW.md b/Week3/REVIEW.md
@@ -0,0 +1,12 @@
+# REVIEW JavaScript week 3
+
+```
+This review covers:
+• More CLI
+• Closures 
+• Scope
+• Array Manipulations 
+• Basic DOM manipulations [img src, innerHTML]
+• Code commenting
+```
+
diff --git a/Week8/README.md b/Week8/README.md
@@ -1,4 +1,4 @@
-# Reading material for the ningth lecture:
+# Reading material for the ninth lecture:
 
 ```
 In week nine we will discuss the following topics:

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# Reading material for the ningth lecture:`
	`1`	`+# Reading material for the ninth lecture:`
`2`	`2`
`3`	`3`	```
`4`	`4`	`In week nine we will discuss the following topics:`