add session 2 notes

Author: gambitier

session 2/chapters/1. comparison.md

@@ -0,0 +1,127 @@
+# comparison
+
+[Refer this tutorial](https://javascript.info/comparison)
+
+- Equals: a == b, please note the double equality sign == means the equality test, while a single one a = b means an assignment.
+- All comparison operators return a boolean value:
+
+A comparison result can be assigned to a variable, just like any value:
+
+```javascript
+let result = 5 > 4; // assign the result of the comparison
+alert(result); // true
+```
+
+in JavaScript, a non-empty string is always true.
+
+```javascript
+alert(Boolean('0')); // true
+alert(Boolean(' ')); // spaces, also true (any non-empty string is true)
+```
+
+# String comparison
+
+strings are compared letter-by-letter.
+
+at any index (which is character) in a string, if character from first string and a character from second string at same index, is greater than the other one then first string is grater.
+
+```javascript
+console.log('Z' > 'A'); // true
+console.log('Glow' > 'Glee'); // true
+console.log('Bee' > 'Be'); // true
+```
+
+![strcmp](../images/string%20comparison%20explanation.jpg)
+
+# Comparison of different types
+
+When comparing values of different types, JavaScript converts the values to numbers.
+
+```javascript
+console.log('2' > 1); // true, string '2' becomes a number 2
+console.log('01' == 1); // true, string '01' becomes a number 1
+```
+
+For boolean values, true becomes 1 and false becomes 0.
+
+```javascript
+console.log(true == 1); // true
+console.log(false == 0); // true
+```
+
+![intersting case](../images/boolean%20string%20comparison.jpg)
+
+# Strict equality
+
+A regular equality check == has a problem. It cannot differentiate 0 from false:
+The same thing happens with an empty string:
+
+```javascript
+console.log(0 == false); // true
+console.log('' == false); // true
+```
+
+**An empty string, becomes a zero while comparing.**
+
+**strict equality operator === checks the equality without type conversion**
+
+There is also a “strict non-equality” operator !== analogous to !=.
+
+```javascript
+console.log(0 === false); // false, because the types are different
+```
+
+# Comparison with null and undefined
+
+**For a strict equality check ===**
+
+```javascript
+console.log(null === undefined); // false, because each of them is a different type
+```
+
+**For a non-strict check ==**
+
+```javascript
+console.log(null == undefined); // true,
+```
+
+**For maths and other comparisons < > <= >=**
+
+null/undefined are converted to numbers: null becomes 0, while undefined becomes NaN.
+
+**Rules with equality operator**
+
+the equality check == for `undefined` and `null` is defined such that, without any conversions, they equal each other and don’t equal anything else.
+
+```javascript
+null == undefined; // true
+null == 0; // (2) false
+```
+
+**An incomparable undefined**
+
+`undefined` gets converted to `NaN` and `NaN` is a special numeric value which returns false for all comparisons even with NaN comparison itself.
+
+```javascript
+NaN != NaN; // true
+```
+
+`undefined` only equals `null`, `undefined`
+
+```javascript
+alert(undefined > 0); // false
+alert(undefined < 0); // false (2)
+alert(undefined == 0); // false (3)
+```
+
+# What will be the result for these expressions?
+
+```javascript
+5 > 4;
+'apple' > 'pineapple';
+'2' > '12';
+undefined == null;
+undefined === null;
+null == '\n0\n';
+null === +'\n0\n';
+```

session 2/chapters/2. type conversions.md

@@ -0,0 +1,145 @@
+# Type Conversions
+
+Most of the time, operators and functions automatically convert the values given to them to the right type.
+
+For example,
+
+- **alert automatically converts any value to a string to show it**.
+- **Mathematical operations convert values to numbers.**
+
+# String Conversion
+
+call the String(value) function to convert a value to a string:
+
+```javascript
+let value = true;
+alert(typeof value); // boolean
+
+value = String(value); // now value is a string "true"
+alert(typeof value); // string
+
+String(false); // "false"
+String(null); // "null"
+```
+
+# Numeric Conversion
+
+- Numeric conversion happens in **mathematical functions** and **expressions** automatically.
+- We can use the Number(value) function to explicitly convert a value to a number:
+
+```javascript
+Number(''); //0
+Number(' '); //0
+```
+
+![numconversion rules](../images/numconversionrule.jpg)
+
+# Boolean conversion rules
+
+Please note: the string with zero "0" is true
+
+```javascript
+alert(Boolean('0')); // true
+alert(Boolean(' ')); // spaces, also true (any non-empty string is true)
+```
+
+![bool conversions](../images/boolean%20string%20comparison.jpg)
+
+# Precedence of operator
+
+if you use same type of operators in an expression (i.e. expression contains numbers) then it will perform left to right operation
+
+```javascript
+alert(5 + 5 + 'px'); // 10px
+alert('px' + 5 + 5); // px55
+```
+
+if you have higher Precedence operators in expression the evaluation will be different
+
+```javascript
+alert('px' + 5 * 5); // px25
+```
+
+For more on this [read here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+
+# Some special functions
+
+## parseFloat() vs parseInt vs Number vs +"(string value)"
+
+parseFloat/parseInt is for parsing a string, while Number/+ is for coercing a value to a number. They behave differently. But first let's look at where they behave the same:
+
+```javascript
+parseFloat('3'); // => 3
+Number('3'); // => 3
+parseFloat('1.501'); // => 1.501
+Number('1.501'); // => 1.501
+parseFloat('1e10'); // => 10000000000
+Number('1e10'); // => 10000000000
+```
+
+parseInt will trucate decimal part
+
+```javascript
+parseInt('12.2'); // 12
+```
+
+However, if your input starts with a number and then contains other characters, parseFloat truncates the number out of the string, while Number gives NaN (not a number):
+
+```javascript
+parseFloat('1x'); // => 1
+parseInt('1x'); // => 1
+parseFloat('3px'); // => 3
+parseInt('3px'); // => 3
+Number('1x'); // => NaN
+```
+
+Number understands hexadecimal input while parseFloat does not:
+
+```javascript
+parseFloat('0x10'); // => 0
+parseInt('0x10'); // => 16
+Number('0x10'); // => 16
+```
+
+Note that using the unary + operator is exactly the same as using Number as a function:
+
+```javascript
+Number('0x10'); // => 16
++'0x10'; // => 16
+Number('10x'); // => NaN
++'10x'; // => NaN
+Number('40'); // => 40
++'40'; // => 40
+```
+
+For empty string, they are different.
+
+- **+"" and Number("") returns 0**
+- **parseFloat("") and parseInt("") returns NaN**
+
+```javascript
+parseFloat(''); // => NaN
+Number(''); // => 0
+parseFloat(' \r\n\t'); // => NaN
+Number(' \r\n\t'); // => 0
+```
+
+## toString() vs String()
+
+value.toString() will cause an error if value is `null` or `undefined`. String(value) should not.
+
+```javascript
+var value = null;
+alert(value.toString()); // TypeError exception
+
+var value = null;
+alert(String(value)); // "null"
+```
+
+# object to primitive
+
+![](../images/object-to-primitive.jpg)
+
+for more [read here](https://javascript.info/object-toprimitive#tostring-valueof)
+
+// TODO Remaining notes here

session 2/chapters/resources.md

@@ -1,3 +1,5 @@
+[javascript.info](https://javascript.info/)
+
 [Array Methods](https://www.digitalocean.com/community/tutorial_series/working-with-arrays-in-javascript)
 
 [string methods - 1](https://www.digitalocean.com/community/tutorials/how-to-work-with-strings-in-javascript)