Gautham

src/exercises/1/exercise.js

@@ -3,7 +3,12 @@
 //  - Fix the issue.
 
 function printOneToTen() {
-  for (const number = 1; number <= 10; number++) {
-    console.log(`\n${number}`);
+  let x = [];
+  for (let number = 1; number <= 10; number++) {
+    // Variables defined with const cannot be Reassigned
+    //console.log(`\n${number}`);
+    x.push(number);
   }
+  return x;
 }
+module.exports = printOneToTen;

src/exercises/1/exercise1.test.js

@@ -0,0 +1,5 @@
+const printOneToTen = require('./exercise.js');
+
+test('print one to ten', () => {
+  expect(printOneToTen()).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+});

src/exercises/10/exercise.js

@@ -15,4 +15,8 @@
 		}
 	]
 */
-function findVoteEligibleCandidates(populationList) {}
+function findVoteEligibleCandidates(populationList) {
+	console.log(`${populationList.filter((element) => element.age >= 18).map((element) => element.name)}`);
+}
+
+module.exports = findVoteEligibleCandidates;

src/exercises/10/exercise10.test.js

@@ -0,0 +1,9 @@
+const findVoteEligibleCandidates = require('./exercise.js');
+
+test('find vote eligible candidates', () => {
+    const consolepass = jest.spyOn(console, 'log');
+    findVoteEligibleCandidates([10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]);
+    expect(consolepass).toHaveBeenCalledWith(`${[10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100].filter((element) => element.age >= 18).map((element) => element.name)}`);
+    findVoteEligibleCandidates([1, 12, 14]);
+    expect(consolepass).toHaveBeenCalledWith(`${[1, 12, 14].filter((element) => element.age >= 18).map((element) => element.name)}`);
+});

src/exercises/11/exercise.js

@@ -2,4 +2,6 @@
 // - Use Array methods
 // - Do not use loops
 
-function sumOfArray(inputArray) {}
+function sumOfArray(inputArray) {
+    return `${inputArray.reduce((total, value) => total + value)}`;
+}

src/exercises/12/exercise.js

@@ -5,5 +5,10 @@ function errorFunction() {
 }
 
 function errorCaller() {
-  errorFunction();
-}
+  try {
+    errorFunction();
+  }
+  catch (error) {
+    console.log(error);
+  }
+}

src/exercises/13/exercise.js

@@ -5,6 +5,14 @@ const employee = {
   lastName: "Teja",
   age: 29,
   id: 1122,
-  getFullName: function () {},
-  checkVoteEligiblity: function () {},
+  getFullName: function () {
+    return this.firstName + " " + this.lastName;
+  },
+  checkVoteEligiblity: function () {
+    if (this.age >= 18) {
+      return "Eligible";
+    } else {
+      return "Not Eligible";
+    }
+  },
 };

src/exercises/14/exercise.js

@@ -8,10 +8,19 @@ const employee = {
   id: 1122,
   getFullName: function () {
     //Copy the solution from the exercise before this.
+    return this.firstName + " " + this.lastName;
   },
 };
 
 const newEmployee = {
   firstName: "New",
   lastName: "Employee",
+  getFullName: employee.getFullName,
+  // or in place of getFullName: employee.getFullName,
+  // you can also write getFullName: employee.getFullName.bind(newEmployee)
+  /* or in place of getFullName: employee.getFullName, this can also be done 
+  __proto__: employee
+  */
 };
+
+//const getFullName = employee.getFullName.call(newEmployee);  //This is one of the way it can be done.

src/exercises/15/exercise.js

@@ -1,10 +1,8 @@
 // Convert the below functions into arrow functions.
 
-const greetings = function () {
-  return "Hello World";
-};
+const greetings = () => "Hello World";
 
-const isEven = function (num) {
+const isEven = (num) => {
   if (num % 2 == 0) {
     return true;
   } else {

src/exercises/16/exercise.js

@@ -2,6 +2,51 @@
 // - Identify the class variables
 // - Create function for all the possible functionalities.
 
-class Leave {
+export class Leave {
   //...
+  constructor(leaveType, leaveStartDate, leaveEndDate) {
+    //...
+    this._leaveType = leaveType;
+    this._leaveStartDate = leaveStartDate;
+    this._leaveEndDate = leaveEndDate;
+    this._leaveDays = this.calculateLeaveDays();
+  }
+
+  get leaveType() {
+    return this._leaveType;
+  }
+
+  get leaveStartDate() {
+    return this._leaveStartDate;
+  }
+
+  get leaveEndDate() {
+    return this._leaveEndDate;
+  }
+
+  set leaveType(leaveType) {
+    this._leaveType = leaveType;
+  }
+
+  set leaveStartDate(leaveStartDate) {
+    this._leaveStartDate = leaveStartDate;
+  }
+
+  set leaveEndDate(leaveEndDate) {
+    this._leaveEndDate = leaveEndDate;
+  }
+
+  calculateLeaveDays() {
+    //...
+    return this._leaveEndDate - this._leaveStartDate;
+  }
+
+  approveLeave() {
+    //...
+    if (this._leaveDays > 5) {
+      console.log("Leave Rejected");
+    } else {
+      console.log("Leave approved");
+    }
+  }
 }

src/exercises/17/exercise.js

@@ -1 +1,45 @@
 // Extend the Leave class, to create different classes for different Leave types.
+import { Leave } from "../16/exercise.js";
+class SickLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Sick", leaveStartDate, leaveEndDate);
+        this.limit = 5;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        sickLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    sickLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Sick leaves left: " + this.limit);
+    }
+}
+
+class CasualLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Casual", leaveStartDate, leaveEndDate);
+        this.limit = 10;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        casuaLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    casuaLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Casual leaves left: " + this.limit);
+    }
+}
+
+

src/exercises/18/CasualLeaveClass.js

@@ -0,0 +1,21 @@
+import { Leave } from "../16/exercise.js";
+class CasualLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Casual", leaveStartDate, leaveEndDate);
+        this.limit = 10;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        casuaLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    casuaLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Casual leaves left: " + this.limit);
+    }
+}

src/exercises/18/SickLeaveClass.js

@@ -0,0 +1,21 @@
+import { Leave } from "../16/exercise.js";
+class SickLeave extends Leave {
+    constructor(leaveStartDate, leaveEndDate) {
+        super("Sick", leaveStartDate, leaveEndDate);
+        this.limit = 5;
+    }
+
+    approveLeave() {
+        if (this._leaveDays > this.limit) {
+            console.log("Leave Rejected");
+        } else {
+            console.log("Leave approved");
+        }
+        sickLeavesLeft(this.limit - this._leaveDays);
+    }
+
+    sickLeavesLeft(limit) {
+        this.limit = limit;
+        console.log("Sick leaves left: " + this.limit);
+    }
+}

src/exercises/18/exercise.js

@@ -1,3 +1,13 @@
 // Use Javascript modules to create seperate files for each of the Leave type classes.
 // - Comment your understanding about import
 // - Comment your understanding about export
+
+/****Import*****/
+//import allows us to import the class, functions, variables from other files and use them in the current file. Modules can be imported in two ways based on the type of export.
+//The imported values are read-only views of the features that were exported. Similar to const variables, you cannot re-assign the variable that was imported, but you can still modify properties of object values. The value can only be re-assigned by the module exporting it.
+
+/****export*****/
+//export allows us to export the class, functions, variables to be used in other files.
+//There are two types of exports: Named Exports and Default Exports. Named Exports are used when we have multiple things to export from a file. Default Exports are used when we have only one thing to export from a file.
+
+//you need to include type="module" in the <script> element, to declare this script as a module. You can only use import and export statements inside modules, not regular scripts. 

src/exercises/19/exercise.js

@@ -1,3 +1,42 @@
 // Comment below what did you understand from the previous 3 exercises about
 // - prototype
 // - __proto__
+
+/*********Prototype*******/
+//  prototype: The prototype property is used to add methods or properties to an object's prototype. The prototype is a shared property of all instances of an object created using the constructor function, and adding a method or property to it will make it available to all instances of that object. It can be used to add methods and properties to an object after it has been created.
+/*                              // A constructor function
+                                function Box(value) {
+                                  this.value = value;
+                                }
+
+                                // Properties all boxes created from the Box() constructor
+                                // will have
+                                Box.prototype.getValue = function () {
+                                  return this.value;
+                                };
+
+                                const boxes = [new Box(1), new Box(2), new Box(3)];
+//Box.prototype it's just a plain object. Every instance created from a constructor function will automatically have the constructor's prototype property as its [[Prototype]] — that is, Object.getPrototypeOf(new Box()) === Box.prototype. Constructor.prototype by default has one own property: constructor, which references the constructor function itself — that is, Box.prototype.constructor === Box. This allows one to access the original constructor from any instance.
+*/
+
+
+/*********__proto__*******/
+// __proto__: The __proto__ property is an internal property of an object that points to its prototype. It is used to access the prototype of an object, and can also be used to set the prototype of an object. When a property is accessed on an object, JavaScript first looks for the property on the object itself, and if it is not found, it looks for it in the object's prototype, and so on up the prototype chain until the property is found or the end of the prototype chain is reached.
+/*                           const o = {
+                                a: 1,
+                                b: 2,
+                                // __proto__ sets the [[Prototype]]. It's specified here
+                                // as another object literal.
+                                __proto__: {
+                                  b: 3,
+                                  c: 4,
+                                  __proto__: {
+                                    d: 5,
+                                  },
+                                },
+                              };
+
+                              // { a: 1, b: 2 } ---> { b: 3, c: 4 } ---> { d: 5 } ---> Object.prototype ---> null
+
+                              console.log(o.d); // 5
+*/

src/exercises/2/exercise.js

@@ -3,11 +3,16 @@
 //  - Fix the issue.
 
 function divideTenByNumber(number) {
+  //Variables defined with let have block scope. They are only accessible within the block they are defined in.
+  let result;
   if (number != 0) {
-    let result = 10 / number;
+    result = 10 / number;
   } else {
-    let result = "Indeterminate";
+    result = "Indeterminate";
   }
 
-  console.log(`Result after dividing 10 by ${number} is ${result}`);
+  //console.log(`Result after dividing 10 by ${number} is ${result}`);
+  return result;
 }
+
+module.exports = divideTenByNumber;

src/exercises/2/exercise2.test.js

@@ -0,0 +1,6 @@
+const divideTenByNumber = require('./exercise.js');
+
+test('divide ten by number', () => {
+    expect(divideTenByNumber(5)).toEqual(2);
+    expect(divideTenByNumber(0)).toEqual("Indeterminate");
+});

src/exercises/20/exercise.js

@@ -1,3 +1,22 @@
 // What is debugger;
 // - Comment your understanding of it.
 // - Paste the link of the MDN article here.
+
+
+// Debugger is a keyword that stops the execution of the code and allows you to inspect the current state of the code. It is useful for debugging purposes.
+
+/*Debugging is the process of finding and fixing errors within a script.
+  A breakpoint is a point of code where the debugger will automatically pause the JavaScript execution.
+  While the code is paused, we can examine current variables, execute commands in the console etc. In other words, we can debug it.
+
+  Watch – shows current values for any expressions.(You can click the plus + and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.)
+
+  Call Stack – shows the nested calls chain.
+
+  Scope – current variables.
+  Local shows local function variables. You can also see their values highlighted right over the source.
+  Global has global variables (out of any functions).
+
+*/
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger

src/exercises/21/exercise.js

@@ -1 +1,8 @@
 // What are the different levels of logs and how do we print them to the console?
+
+/* logs are used to debug the code. There are 4 levels of logs:
+1. console.log() - used to print the output to the console.
+2. console.info() - used to print the information to the console.
+3. console.warn() - used to print the warning to the console.
+4. console.error() - used to print the error to the console.
+*/