finished this.js

drgreen2003 · drgreen2003 · commit c2498a593df2 · 2018-03-21T16:29:52.000-04:00
diff --git a/recursion.js b/recursion.js
@@ -10,9 +10,15 @@ while (n <= 10) {
 // write a recursive - function called countToTen that mimics the while loop above.
 
 // code here
-
+function coundToTen(n){
+  if(n === 10){
+    return;
+  }
+  console.log(n);
+  coundToTen(++n);
+}
 // when you code is ready, un-comment the next line and run the file
-// console.log(countToTen());
+console.log(countToTen(1));
 /* ================ Next Problem ================= */
 
 // Problem 2:
@@ -28,6 +34,11 @@ const factorial = n => {
 console.log(factorial(5));
 
 // write the above function in a recursive way.
-
+function recursiveFactorial(n){
+if(n === 1){
+  return 1;
+}
+return n * recursiveFactorial(n-1);
+}
 // when your code is ready, un-comment the next line and run the file
-// console.log(recursiveFactorial());
+console.log(recursiveFactorial(10));
diff --git a/this.js b/this.js
@@ -1,11 +1,19 @@
 /* The for principles of "this";
 * in your own words. explain the four principle for the "this" keyword below.
-*
-* 1. 
-* 2. 
-* 3. 
-* 4. 
-*
+* this keyword have 4 scopes.
+* 1. Global Scope
+in global scope the this keyword points to the global object in system it is windows object and in a browser its browser object. 
+if we have not binded the object to any other object implicitly its this scope will be the global. 
+
+* 2. Implicit binding scope
+implicit binding is when we invoke this keyword within a method of any object. In this case every first child method, its this will point to the object itself. 
+if we have any inner object inside a object the this points to the global object. 
+
+* 3. Explicit binding scope 
+Explicit binding is when we use call , apply or bind to any function. we define what the this keyword will point to in the first parameter of call, apply and bind. 
+
+* 4. New keyword binding scope
+this is when we use a constructor function to create new objects, and then, this keyword points to the parameter passed into the constructor.
 * write out a code example of each explanation above
 */
 
@@ -14,15 +22,63 @@ console.log('hello world!');
 // Principle 1
 
 // code example for Window Binding
+console.log(this) // here this is the window object.
 
 // Principle 2
 
 // code example for Implicit Binding
+let newObj = {
+    name: 'imran', 
+    age: 30, 
+    getAgeAndName: function(){
+        return this.name + ' ' + this.age; // here this points to the newObj(parent object);
+        child: function any(){
+            console.log(this);  // but here this will be the global object(window);
+        }
+    }
+}
 
 // Principle 3
 
 // code example for New Binding
+function ConstExample(param1, param2) {
+    this.name = param1; // here this points to the parameter passed 
+    this.age = param2;
+}
+
+let childObj = new ConstExample('imran' , 30); 
+console.log(childObj) // ---> {name: imran, age: 30}
 
 // Principle 4
 
 // code example for Explicit Binding
+
+function any(param1, param2){
+    return this.name + ' ' + this.age + 'and i like to ' + param1 + 'and' + param2; 
+}
+
+let testObj = {
+    name: 'imran', 
+    age: 30
+}; 
+
+
+let testparams = ['code', 'music' ]; 
+                    //call example
+// here we are setting the this of any() to testObj1, note the this.age and param2 will return undefined;
+console.log(any.call(testObj, 'code')); 
+
+
+                    //apply example
+// same as call , but expects an array as parameter. 
+//call and apply both invokes the any();                    
+console.log(any.apply(testObj, testparams)) 
+
+
+                    // bind example
+// same as call and apply , expects a parameter or comma seperated parameters(not array) as second argument. 
+//but unlike call and apply it creates another version of the function(any()), and dose not invoke the newly created function. 
+//we can use a variable to capture the newly created function with the this keyword specified to a object. 
+//this new funciton whenever we invoke will always point to the testObj as its this . 
+let bindTest = (any.bind(testObj, 'code'));
+console.log(bindTest())                 
