sundeeep
diff --git a/‎Closures/Closures.txt
Lines changed: 19 additions & 0 deletions b/‎Closures/Closures.txt
Lines changed: 19 additions & 0 deletions
diff --git a/‎Closures/Demonstartion/01 Closures.js
Lines changed: 15 additions & 0 deletions b/‎Closures/Demonstartion/01 Closures.js
Lines changed: 15 additions & 0 deletions
diff --git a/‎Closures/Demonstartion/index.html
Lines changed: 16 additions & 0 deletions b/‎Closures/Demonstartion/index.html
Lines changed: 16 additions & 0 deletions
diff --git a/‎Functions/CallBack Functions/CallBack Func().txt
Lines changed: 22 additions & 0 deletions b/‎Functions/CallBack Functions/CallBack Func().txt
Lines changed: 22 additions & 0 deletions
diff --git a/‎Functions/Higher-Order Fn().txt b/‎Functions/Higher-Order Fn().txt
diff --git a/‎Namaste-JS-Planning.xlsx
9.82 KB b/‎Namaste-JS-Planning.xlsx
9.82 KB
diff --git a/‎Need-To-Cover.jpg
178 KB b/‎Need-To-Cover.jpg
178 KB
diff --git a/‎Random-Notes.txt
Lines changed: 41 additions & 0 deletions b/‎Random-Notes.txt
Lines changed: 41 additions & 0 deletions
@@ -0,0 +1,19 @@
+Closure Definition:
+
+
+Closures have a lot of advantages and real -world examples:
+
+1. Module Pattern
+2. Function Currying
+3. Higher Order Functions (memoize, ones)
+4. Data Hiding and Encapsulation
+
+
+Data Hiding and Encapsulation:
+-> 
+
+Disadvantages of Closures:
+
+-> Those closed variables are not garbage collected,
+-> If not handle properly, Memory can be leaked and browser can be freeezed.
+-> Closures consume so much Heap Memory Becuase those variables which are present inside the Closure Function can be Garbage collected.
@@ -0,0 +1,15 @@
+let num = 10;
+
+const outer = () => {
+    let num = 10;
+    const inner = () => {
+        // let num = 20
+        const core = () => {
+        console.log("In Core", num);
+        };
+        return core;
+    };
+    return inner;
+};
+
+outer()()();
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Closures</title>
+</head>
+
+<body>
+    <h1>Javascrip: Closures</h1>
+    <script defer src="./01 Closures.js"></script>
+</body>
+
+</html>
@@ -0,0 +1,22 @@
+What is a Callback Function in Javascript
+
+-> You can take a function which can be passed into another function, the function which has been passed is called CallBack Function.
+
+-> With the help of "callback" functions, we can do "asynchronous" tasks in a synchronous - single threaded Javascript.
+
+Example: setTimeout(handler, delay);
+"handler is the call back function."
+
+Power of a Callbacks?
+
+Deep about the Event Listeners?
+
+document.getElementById("clickMe")
+.addEventListener("click", function cb(){
+	console.log("Button Clicked!");
+})
+
+
+-> Even Listeners are heavy, It consumes the Memory. The program can't free up the Memory which stores the Event Listeners.
+e.g., onclicke, onclose, onscroll, onhover
+
@@ -0,0 +1,41 @@
+Akshay's Suggestions:
+-> ECMASCRIPT 6 Standards Documentation, 
+
+What is Lexical Environment?
+Whenever Global Execution Context is created, the Lexical Environment is also created. Lexical environment is a local memory along with the lexical environment of it's parent.
+
+-> Lexical means "in heirarchy" or "in a sequence".
+
+function a(){
+	var b= 10;
+	c();
+	function c(){
+		...
+	}
+}
+
+a();
+
+-> c func() is lexically inside a func().
+-> where that code is present physically inside where?
+-> a func() is lexically inside the global scope.
+
+-> Local Memory along with Lexical environment of it's Parent.
+
+-> Whenever the Global Execution Context is created, then in the Memory Allocation part, The reference of the Local Memory as well as Lexical Environment of it's Parent also been created.
+
+-> Scope Chaining is the chain of all the lexical environments of it's parent's references.
+
+-> Lexical Environment = Local Memory + Lexical Environment of it's Parent(where it's lexically present).
+
+-> Scope is defined that, whether a function or variable present inside the Scope Chain.
+ 
+
+
+***Anonymous Function, First Class Function, and Higher Order Function, Call Back Function***
+
+***Function Statement, Function Expression and Function Declaration.***
+
+Answers: 
+
+->