Update

.eslintrc.js

@@ -6,6 +6,7 @@ module.exports = {
     "quotes": ["error", "double"],
     "semi": ["error", "always"],
     "eol-last": ["error", "never"],
-    "no-multiple-empty-lines": ["error", { max: 1 }]
+    "no-multiple-empty-lines": ["error", { max: 1 }],
+    "no-var": ["error"]
   }
 };

.gitignore

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

JavaScript_Advance/arrow_function.js

@@ -1,14 +1,28 @@
 let a = () => {
   // This is arrow function came new in ES6
+  //It assigns the function to variable a as the identifier with let instead and adds arrows before the curly braces. 
+
 };
 
+
+let multiply = (num) => num * num 
+
+//arrow functions also works without curly braces {} and can directly write expression after the arrows 
+// this is known as concise body as opposed to a block body (with {});
+//cannot be used with if statements, or an error will appear since it only takes one expression; 
+//ternary operators can be used with arrow functions as a more concise way to write if statements 
+
+
+
 let info = {
   firstName: "Swapnil",
   lastName: "Shinde",
   getFullName: () => {
-    return(`My name is ${this.firstName} ${this.lastName}`); // Arrow functions don't have "this" property
+    return (`My name is ${this.firstName} ${this.lastName}`); // Arrow functions don't have "this" property
   }
 }
+//not having this. binding means it also cannot be called with new and used as a constructor 
+
 
 console.log(info.getFullName());
 // Output My name is undefined undefined that's why we don't use this with arrow function
@@ -17,7 +31,7 @@ let newInfo = {
   firstName: "Swapnil",
   lastName: "Shinde",
   getFullName: () => {
-    return(`My name is ${newInfo.firstName} ${newInfo.lastName}`); // If we are using arrow function then directly use the variables as shown
+    return (`My name is ${newInfo.firstName} ${newInfo.lastName}`); // If we are using arrow function then directly use the variables as shown
   }
 }
 
@@ -31,32 +45,42 @@ class Student {
   }
 
   getName = () => {
-    return this.name;
+    return this.name; 
   }
 }
 
 console.log((new Student).getName()) // Gives error for node versions before 12.4.0(Approx) SyntaxError: Unexpected token = 
 
 class StudentInfo {
 
-  constructor (firstName,lastName, age, branch, college){ 
-    this.firstName = firstName; 
+  constructor(firstName, lastName, age, branch, college) {
+    this.firstName = firstName;
     this.lastName = lastName;
-    this.age = age; 
+    this.age = age;
     this.branch = branch;
     this.college = college;
   };
 
   getFullName = () => { // Returns full name using string interpolation
-    return(`My name is ${this.firstName} ${this.lastName}`); // If we are using arrow function then directly use the variables as shown
+    return (`My name is ${this.firstName} ${this.lastName}`); // If we are using arrow function then directly use the variables as shown
   };
 
   getBranch = () => { // Returns Branch 
-    return(this.branch);
+    return (this.branch);
   };
 
 }
 
-let Swapnil = new StudentInfo("Swapnil", "Shinde",19, "Computer", "Sies"); // This way we can create new objects with arguments
+let Swapnil = new StudentInfo("Swapnil", "Shinde", 19, "Computer", "Sies"); // This way we can create new objects with arguments
+
+console.log(Swapnil.getFullName()); // Output My name is Swapnil Shinde
+
+//settimeout without arrow function
+setTimeout(function () {
+  console.log("hello world");
+}, 1000);
 
-console.log(Swapnil.getFullName()); // Output My name is Swapnil Shinde
+//settimeout with arrow function
+setTimeout(() => {
+  console.log("hello world");
+}, 0); //arrow functions provide better readability

JavaScript_Advance/callback.js

@@ -62,7 +62,7 @@ transformNumber(10, (num) => {
   * passed to the `resolve()` function, will get passed to the function passed to `.then()`
   * function. Look at the following example from MDN official documents:
   */
-var p1 = new Promise((resolve, reject) => {
+const p1 = new Promise((resolve, reject) => {
   resolve("Success!");
   // or
   // reject(new Error("Error!"));

JavaScript_Advance/cookies.js

@@ -6,7 +6,7 @@ console.log("Simple usage:" + document.cookie);
 // #2 Get a cookie with the name 'actor'
 document.cookie = "movie=Jungle Book";
 document.cookie = "actor=Balu";
-var cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)actor\s*\=\s*([^;]*).*$)|^.*$/, "$1");
+const cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)actor\s*\=\s*([^;]*).*$)|^.*$/, "$1");
 console.log("Cookie with the name 'actor':" + cookieValue);
 
 // #3 Set cookie and execute code only once if cookie doesn't exist yet

JavaScript_Advance/do_while_loop.js

@@ -10,7 +10,7 @@ do {
 
  */
 
-var n = 1;
+let n = 1;
 
 do {
   console.log("n is less than 6. n = " + n);

JavaScript_Advance/event_loop.js

@@ -4,4 +4,14 @@ setTimeout(() => {
 
 console.log("Last statement"); // This statement gets printed first
 
-// This enables the non blocking using event based management
+// This enables the non blocking using event based management
+
+console.log("a");
+setTimeout(() => {
+  console.log("b");
+}, 2000);
+console.log("c");
+setTimeout(() => {
+  console.log("d");
+}, 0);
+// except answer : a , c , d , b

JavaScript_Advance/filtering_array.js

@@ -2,4 +2,19 @@ const animals = ["cats", "dogs", "bunnies", "birds"];
 
 const start_with_b = animals.filter(name => name.indexOf("b") === 0);
 
-console.log(start_with_b); // ['bunnies', 'birds']
+console.log(start_with_b); // ['bunnies', 'birds']
+
+// function of filter (basic callback for filter)
+const arr = [1, 3, 42, 2, 4, 5];
+function filter (array, callback) {
+  const callback_list = [];
+  for (const i of array) {
+    callback_list.push(callback(i));
+  }
+  return callback_list;
+}
+// modifyable callback function
+function callback (num) {
+  return Math.pow(num, 2);
+}
+console.log(filter(arr, callback));

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_Advance/hoisting.js

@@ -23,4 +23,10 @@ elem.innerHTML = x; // Display x in the element
 /* Conclusion :Example 1 gives the same result as Example 2
 so, Hoisting is JavaScript's default behavior of moving all declarations to the top of the current scope
 (to the top of the current script or the current function)
-*/
+*/
+
+console.log(foo);
+const foo = "foo"; // unable to print due to the hoisting behaviour
+
+console.log(ok);
+var ok = "this is printing";// var is hoisted

JavaScript_Advance/promises.js

@@ -40,7 +40,7 @@ getAsyncDataWithPromises()
   .then(data => {
     // ... use data
   }).catch(e => {
-  // ... handle exception
+    // ... handle exception
   });
 
 // promises promise the nodejs main thread that i'm going to come after doing a particular task
@@ -77,4 +77,25 @@ asyncCall
   // appended with ' bar' to become 'foo bar'
   .then(val => `${val} bar`)
   // console logs 'foo bar'
-  .then(console.log);
+  .then(console.log);
+
+// promise.all();\
+const fs = require("fs");
+const dir = __dirname + "/text/";
+const promisesarray = ["Text file content start after this : "];
+function readfile () {
+  fs.readdir(dir, "utf-8", (err, File) => {
+    File.forEach(file => {
+      promisesarray.push(new Promise((resolve, reject) => {
+        fs.readFile(dir + file, "utf-8", (err, data) => {
+          if (err) reject(err);
+          else resolve(data);
+        });
+      }));
+    });
+    Promise.all(promisesarray).then(data => {
+      console.log(data);
+    });
+  });
+}
+readfile();

JavaScript_Advance/recursion.js

@@ -0,0 +1,32 @@
+// Recursion is when a function calls itself.
+// Recursion gives us an interesting way to write algorithms that can solve complicated problems.
+
+// Take for example factorials which is just an integer times each of the integers below it: so 5 factorial (also written 5!) is just 5 * 4 * 3 * 2 * 1.
+// If we want to write an algorithm that can calculate the factorial of any given number without using recursion, we could do something like this:
+
+function calcuateFactorialWithoutRecursion (num) {
+  let total = num;
+  let nextNumber = num - 1;
+  while (nextNumber >= 1) {
+    total = total * nextNumber;
+    nextNumber--; // decrease the next number by 1
+  }
+  return total;
+}
+
+// calcuateFactorialWithoutRecursion(5) // 120
+// 5 * 4 * 3 * 2 * 1 = 120
+
+// We can write the same function this way using recursion:
+function calculateFactorialWithRecursion (num) {
+  if (num === 1) { // This step is critical. The num parameter will keep decreasing until it gets to 1.
+    // Once the function gets called with 1 as a parameter, the function will return without calling itself.
+    return num;
+  }
+  return num * calculateFactorialWithRecursion(num - 1);
+}
+
+calculateFactorialWithRecursion(7); // 5040
+// 7 * 6 * 5 * 4 * 3 * 2 * 1 = 5040
+
+// See how clean recursion made this algorithm!

JavaScript_Advance/timer_functions.js

@@ -1,22 +1,22 @@
 // setTimeout setInterval in both functions the time is specified in millisecond
 
-// setTimeout This runs a code after given time starting form calling this method in program.
+// setTimeout This runs a code after given time starting from calling this method in program.
 
 setTimeout(() => {
-  console.log("SetTimeout is Called");
+    console.log("SetTimeout is Called");
 }, 5000); // This will print SetTimeout is Called after 5sec after calling it
 
 // For stopping this we can use ClearTimeout
 
 // setInterval This runs a code after specific interval of time till we stop the timer.
 
 starting = setInterval(() => {
-  console.log("SetInterval is Called");
+    console.log("SetInterval is Called");
 }, 3000); // This will print setInterval is Called after every 3sec
 
 // We can stop the interval and timeout using clearTimeout and clearInterval
 setTimeout(() => {
-  clearInterval(starting);
+    clearInterval(starting);
 }, 7000);
 
 // Output of this whole program is

JavaScript_Advance/while_loop.js

@@ -10,9 +10,14 @@
 
  */
 
-var n = 1;
+let n = 1;
 
 while (n < 6) {
   console.log("n is less than 6. n = " + n);
   n++;
-}
+}
+
+let sum = 1;
+do {
+  console.log(`sum now is ${sum++}`);
+} while (sum <= 100);

JavaScript_Basics/Datatypes.js

@@ -0,0 +1,3 @@
+var length = 16; // Number
+var lastName = "Johnson"; // String
+var x = { firstName: "John", lastName: "Doe" }; // Object

JavaScript_Basics/arrays.js

@@ -27,26 +27,26 @@ console.log(easyMethod);
 // Output [ 'Swapnil Satish Shinde', 76, true ]
 
 // The pop() method removes the last element from an array:
-var fruits = ["Banana", "Orange", "Apple", "Mango"];
+const fruits = ["Banana", "Orange", "Apple", "Mango"];
 fruits.pop(); // Removes the last element ("Mango") from fruits and output is ["Banana","Orange","Apple"]
 
 // Shifting is equivalent to popping, working on the first element instead of the last.
 // The shift() method removes the first array element and "shifts" all other elements to a lower index.
-var cars = ["Acura", "Audi", "Bugatti", "Honda"];
+const cars = ["Acura", "Audi", "Bugatti", "Honda"];
 cars.shift(); // Removes the first element ("Acura") from cars and output is ["Audi","Bugatti","Honda"]
 
 // The length property provides an easy way to append a new element to an array:
-var mobiles = ["Apple", "Nokia", "Samsung", "Sony"];
+const mobiles = ["Apple", "Nokia", "Samsung", "Sony"];
 mobiles[mobiles.length] = "HTC"; // Appends "HTC" to mobiles and output is ["Apple", "Nokia", "Samsung", "Sony", "HTC"]
 
 // delete will delete the object property, but will not reindex the array or update its length. This makes it appears as if it is undefined:
-var myArray = ["a", "b", "c", "d"];
+const myArray = ["a", "b", "c", "d"];
 delete myArray[0];
 "The first value is: " + myArray[0]; // The first value is: undefined
 // Using delete may leave undefined holes in the array. Use pop() or shift() instead.
 
 // The splice() method removes items from array and/or adds items to array and returns the removed items:
-var names = ["Anne", "Belle", "Chloe", "Diane", "Ella", "Frances"];
+const names = ["Anne", "Belle", "Chloe", "Diane", "Ella", "Frances"];
 names.splice(4, 1);
 // This removes 1 item from index 4
 // returns "Ella"

JavaScript_Basics/bugs.js

@@ -1,8 +1,8 @@
-var obj = {
+const obj = {
   name: "Some name"
 };
 
-var name = null;
+const name = null;
 
 console.log(typeof obj); // object;
 console.log(typeof name); // object;