Merge pull request Swap76#1 from Swap76/master

take latest

Author: anuk79

docs/JavaScript_Basics/condition_statments.md

@@ -1 +1,74 @@
-# IF, ELSE IF, ELSE CONDITION
+# IF, ELSE IF, ELSE CONDITION
+Conditional statements run specific blocks of code based on certain parameters that you set. Like other code it reads top to bottom so the order that you put your conditions in matter.
+
+Example of an if/else if/else:
+```js
+if(this statement is true){
+ do this
+} else if (this statement is true){
+ do this
+} else{
+ do this
+}
+```
+`If` always comes first and have a set of parenthesis with a statement in them that you are checking to see if it's true. If it is, the code in the curly brackets is run, otherwise it would move on to the `else if`, and see if that statement is true. If `else if` is true then it runs that block of code, if not then it would run the code in the `else` statement. Once a statement is deemed true and the code is run it doesn't continue to read through the code even if there is a more accurate statement lower down. A good example of where this matters would be the common coding challenge fizzbuzz. The idea of fizzbuzz is that you want to log all the numbers from 1-100 however if it's divisible by 3 print "fizz", 5 print "buzz", and if it's divisible by both 3 and 5 print "fizzbuzz".
+If we write our if's the way the problem is stated we would would write:
+```
+if(num % 3 == 0){
+ console.log("fizz")
+} else if(num % 5 == 0){
+ console.log("buzz")
+} else if(num % 3 == 0 && num % 5 == 0){
+ console.log("fizzbuzz")
+} else {
+ console.log(num)
+}
+```
+In this case every time we'd hit a number that should print fizzbuzz we'd get fizz because that is a truthful statement and it's not looking for a more correct answer.
+To account for that we'd want to adjust our statement order to:
+```js
+if(num % 3 == 0 && num % 5 == 0){
+ console.log("fizzbuzz")
+} else if(num % 5 == 0){
+ console.log("buzz")
+} else if(num % 3 == 0){
+ console.log("fizz")
+} else {
+ console.log(num)
+}
+```
+
+## What if we don't write else if but just another if?
+Sometimes you see code that has a number of `if`'s in a row but no `else if`'s or `else`'s in this case it's checking each condition in that case each `if`
+
+This code will only print "it's a number":
+```js
+var number = 2
+if(typeof number === "number"){
+console.log("it's a number")
+} else if(number % 2 === 0){
+console.log("it's even")
+}
+```
+However this code will print both "it's a number" and "it's even"
+```js
+var number = 2
+if(typeof number === "number"){
+console.log("it's a number")
+}
+if(number % 2 === 0){
+console.log("it's even")
+}
+```
+
+## What if we only have an if?
+If there is only one `if` then it only does that code `if` the condition is true and nothing if it's false.
+
+For example:
+```js
+if(number % 2 === 0){
+console.log("it's even")
+}
+console.log(number)
+```
+In this case if `number` is even it will print it's even and it will always print the number.

docs/JavaScript_Basics/objects.md

@@ -26,5 +26,11 @@ Objects are variables too. But objects can contain many values.
 The values are written as name : value pairs (name and value separated by a colon).
 
 Example:
-var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
-
+```js
+var person = { 
+ firstName:"John", 
+ lastName:"Doe", 
+ age:50, 
+ eyeColor:"blue"
+ };
+```

docs/JavaScript_Basics/this.md

@@ -1 +1,102 @@
-# This
+
+# 'this' keyword 
+
+JavaScript's 'this' keyword refers to the object it belongs to. It's values depends on where it is used.
+
+ 
+## 'this' as global variable
+If `this` is used alone, it refers to a global object. In browsers it refers to Window Object as Global Object.
+
+```javascript
+var k = this;
+console..log(k)
+
+/* Output
+
+Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, parent: Window, …}
+
+ */
+
+```
+
+ ## 'this' in a function
+
+In JavaScript, by default the owner of the function is `this`. The value of this in a function refers to the object it belongs to. In below example, `this` refers to window object, so instead of printing '5' it refers to global value '10'.
+
+```javascript
+var x =10;
+function printX() {
+var x = 5;
+console.log(this.x)
+}
+
+printX(); /* its like this.printX() or window.printX() */
+
+
+/* Output
+10 /* this refers to global object so prints 10 */
+*/
+```
+
+## 'this' in function - strict mode
+
+if `use strict` mode is enabled, `this` don't refer to the global object by default. It gives `undefined` when a function is called without explicitly using `this`
+
+```javascript
+// setInterval This runs a code after specific interval of time till we stop the timer.
+`use strict'
+var x =10;
+function printX() {
+var x = 5;
+console.log(this.x)
+}
+this.printX();
+printX(); 
+
+/* Output
+10	// printX() called with this 
+ Uncaught TypeError: Cannot read property 'x' of undefined // printX() called without this 
+ */
+```
+
+ ## 'this' in a method 
+
+In JavaScript, `this` in a method refers to the object of which the method belongs to. In below example, the `printX` method belongs to person object. so `this` refers to person object.
+
+```javascript
+var firstName = "John";
+var person = {
+firstName: "Jenny",
+printX : function() {
+console.log(this.firstName)
+}
+}
+person.printX();
+
+/* Output
+ Jenny
+*/
+```
+
+## Explicit function binding
+Calling `object A` method, using values of `object B` is called Explicit function binding. JavaScript provides two method `call()` and `apply()`
+ 
+For more details read on [call()](/JavaScript_Basics/call) and [apply()](/JavaScript_Basics/apply) .
+ 
+
+```javascript
+var personA = {
+firstName: "Jenny",
+printX : function() {
+console.log(this.firstName)
+}
+}
+var personB = {
+firstName: "John"
+}
+personA.printX.call(personB);
+
+/* Output
+ John
+*/
+```