Merged the repos

Author: Swap76

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 package-lock.json
 docs/_sidebar.md
+.DS_Store

JavaScript_Advance/generators.js

@@ -0,0 +1,30 @@
+/*
+    Generators are functions with the possibility of exit and subsequent entry.
+    Their execution context (variable values) is preserved on subsequent inputs.
+*/
+
+// Let's consider a simple example:
+function* myGenerator() {
+    yield 5
+    yield 6
+}
+
+// In the example above, we wrote a simple generator function with asteriks(*) notation.
+// Next to the yield we put values that are going to be extracted from the function
+// In order to extract them one by one, we should at first call myGenerator function
+
+const gen = myGenerator()
+
+// The returning value of myGenerator function is a object-iterator. It has next() method
+// Which we may call to get the current generator function value:
+
+gen.next().value // 5
+
+// We get the value field of 'next' method's returning value, wich is an object as well
+// Let's call this again in order to get the next value:
+
+gen.next().value // 6
+
+// After we iterate through all the values, the next value is going to be undefined.
+
+gen.next().value // undefined.

JavaScript_Advance/get_environment_variable.js

@@ -0,0 +1,7 @@
+//  Getting values of environment variables
+//  For example, getting username of machine
+const ENV_VARIABLE_KEY = "USER";
+
+const ENV_VARIABLE_VALUE = process.env[ENV_VARIABLE_KEY];
+
+console.log(ENV_VARIABLE_VALUE);

JavaScript_Basics/boolean.md

@@ -0,0 +1,36 @@
+### What are boolean data types?
+
+JavaScript **Boolean** is a data type which can store any one of two values, **true** or **false**.
+E.g. - 
+
+```
+// Javascript has a specific constructor for creating Boolean type objects
+const testValue = new Boolean(true);
+console.log(testValue);    // it prints **Boolean {true}** since testValue is an Object of type Boolean
+```
+
+We can directly assign boolean value to any variable, like below:
+
+```
+const isTrue = true;
+const isfalse = false;
+```
+
+In JavaScript, a **truthy** value is a value that translates to true when evaluated in a Boolean context. 
+All values are truthy unless they are defined as **falsy**.
+
+Javascript treats an empty string (**""**), **0**, **undefined** **null** and **NaN** as **falsy**.
+
+Not operator or **!** is the operator which is used to **negate** the boolean aspect of a value.
+
+For example:
+```
+const val = 12;
+// using ! operator
+console.log( !false );   // prints true
+console.log( !12 );      // prints false, since 12 is truthy value and negation of a truthy value is falsy
+// using !! operator - this returns just the boolean context of any value
+console.log( !!true );   // prints true
+console.log( !!false );  // prints false
+console.log( !!12 );     // prints true, since 12 is truthy value and negation of a truthy value is falsy, and again negation of that false value is truthy
+```

JavaScript_Basics/inheritance.js

@@ -1,6 +1,63 @@
-// common functions are combined in a class to have less repetition in code
+/* 
+// ====================================
+// ====================================
+// BASE INHERITANCE EXAMPLE
+// ====================================
+// ====================================
+*/ 
 
-class Animals { // Animal class is created where the legs are defined 4
+let baseObject = {
+  a: 1,
+  b: 2
+}
+
+// Create a new object with baseObject as the prototype for extendedObject.
+let extendedObject = Object.create(baseObject);
+
+// Define property c to the baseObject.
+// This is not explicitly defined on extendedObject
+// but is accessible via the [[Prototype]].
+baseObject.c = 3;
+
+// It appears that there are no properties on extendedObject
+console.log(extendedObject) // {}
+
+// a and b were defined on the baseObject.
+// The property looks up the prototype chain
+// until the properties of a and b exist or null is encountered for [[Prototype]].
+console.log(extendedObject.a); // 1
+console.log(extendedObject.b); // 2
+
+// Define d on the extendedObject
+// this is not accessible to the baseObject
+// as the [[Prototype]] inherits one way
+extendedObject.d = 4;
+
+// We now see property d on extendedObject
+console.log(extendedObject) // { d: 4 }
+
+// c is accessible because the prototype chain is "alive".
+// As properties are added or deleted, they can be accessed 
+// by objects that share a prototype
+console.log(extendedObject.c); // 3
+
+// d is accessible on extendedObject where it was defined
+// but is inaccessible to baseObject and returns undefined
+console.log(extendedObject.d); // 4
+console.log(baseObject.d) // undefined
+
+
+/* 
+// ====================================
+// ====================================
+// CLASS BASED INHERITANCE EXAMPLE
+// ====================================
+// ====================================
+*/ 
+
+// Animal class is defined with a property of legs and a method of getLegs 
+// which returns the current value of legs. 
+class Animal { 
   constructor () {
     this.legs = 4;
   }
@@ -10,26 +67,97 @@ class Animals { // Animal class is created where the legs are defined 4
   }
 }
 
-class Dog extends Animals {
+// Dog inherits the base properties from Animal 
+// and adds its own property of age (which is not shared with Animal) 
+// and the methods getAge and getSound
+class Dog extends Animal {
   constructor (age) {
-    super(); // As We have to also call the constructor of Animals if constructor is empty this automatically calls the super
+
+    // We need to call super in order to instantiate the constructor on Animal.
+    // If super is not called, then legs would be inaccessible to the Dog class
+    super(); 
     this.age = age;
   }
 
-  // we have inherited the animals so getLegs method is also there in Dog class
   getSound () {
-    return ("Bhow");
+    return ("Bow");
   }
 
   getAge () {
     return (this.age);
   }
 }
 
-const tommy = new Dog(10); // Created Object of Dog class
+ // Create a new Dog object passing in 10 for the age parameter
+const tommy = new Dog(10);
 
+// Since the Dog class extends the Animal class
+// tommy has access to the getLegs method
 console.log(tommy.getLegs()); // Output 4
 
-console.log(tommy.getSound()); // Bhow
+console.log(tommy.getSound()); // Bow
+
+console.log(tommy.getAge()); // 10
+
+
+/* 
+// ====================================
+// ====================================
+// Function Based Inheritance Example
+// ====================================
+// ====================================
+*/ 
+
+// This function defines the base "constructor" for us and is 
+// comparable to the constructor function found in the class example
+function Animal() {
+  this.legs = 4;
+}
+
+// Adding the getLegs property to the prototype ensures that 
+// it will be inherited to any objects that are created from Animal
+Animal.prototype.getLegs = function() {
+  return this.legs;
+}
+
+// The Dog function acts as the constructor, but where is the super call
+// that we use to call the constructor from Animal?
+function Dog(age) {
+  // the call method is similar in function to calling the super method in the 
+  // super method in the class based example. In this case, it instantiates the
+  // legs property
+  Animal.call(this);
+
+  this.age = age;
+}
+
+// We set the prototype of Dog to the prototype of Animal 
+// in order to have access to the getLegs method that is 
+// defined on Animal's prototype
+Dog.prototype = Object.create(Animal.prototype);
+
+// Dog is set as the constructor property on the Dog prototype to 
+// match the object structure of the class example
+Dog.prototype.constructor = Dog;
+
+// Define getSound method
+Dog.prototype.getSound = function() {
+  return ("Bow");
+}
+
+// Define getAge method
+Dog.prototype.getAge = function() {
+  return (this.age);
+}
+
+// create new Dog with age 10
+const tommy = new Dog(10);
+
+console.log(tommy); // Dog { legs: 4, age: 10 }
+
+// call getLegs that was inherited from Animal
+console.log(tommy.getLegs()); // 4
 
-console.log(tommy.getAge()); // 10
+// call both getSound and getAge that are defined on Dog
+console.log(tommy.getSound()); // Bow
+console.log(tommy.getAge()); // 10

JavaScript_Basics/math.js

@@ -13,7 +13,10 @@ Math.min(50, 50, 810, 2200, -900); // will return -900
 Math.max(230, 250, 10, 300, -900); // will return 300
 
 // round function
-Math.random(); // returns a random number
+Math.round(5.899); 
+
+// returns a random number that is not an integer between 1 to 10.
+Math.random() * (10 - 1) + 1;
 
 // Defining variables to carry out the mathematical functions on.
 value1 = 10;