refactor: table method

Author: brijeshkumar-chavda

11_array/4_array_destructuring.js

@@ -1,7 +1,7 @@
 // Array Destructure
 
 // What
-// - Array destructuring is a feature in JavaScript that allows you to extract values from an array and assign them to individual variables.
+// - Array destructuring is a feature in JavaScript that allows you to extract elements from an array and assign them to individual variables.
 
 const myArray = [1, 2, 3, 4, 5];
 

13_function/arrow_function.js

@@ -1,6 +1,6 @@
 // Arrow Function
 
-// SYNTAX
+// Syntax
 // const variableName = () => {
 //    code...
 // return

25_asynchronous_javascript/1_asynchronous_operation/asynchronous_operation.md

@@ -1,5 +1,7 @@
 # Asynchronous Operation
 
+Video: https://youtu.be/zgt5oTD3rRc?si=C_v1lcoCLHwkmZD0
+
 What
 
 - An asynchronous operation is a process that starts but doesn't necessarily finish immediately.

25_asynchronous_javascript/call_back/1_call_back.js 25_asynchronous_javascript/3_call_back/1_call_back.js

@@ -1,5 +1,7 @@
 // Call Back Function
 
+// Video: https://youtu.be/i2SPq-nb3NQ?si=WDJvXblySIo-A9wi
+
 // What
 // - A call back function is a function which passed as an argument to another function.
 // - Call back function called after the main function completes its execution.

25_asynchronous_javascript/call_back/2_call_back_hell.js 25_asynchronous_javascript/3_call_back/2_call_back_hell.js

@@ -1,8 +1,10 @@
 // Call back function
 
+// Video
+// https://youtu.be/NOlOw03qBfw?si=VFjF1eUuPxogVf1a
 // https://youtu.be/bx9xYPt2tdc
 
-function firstFunction(callback) {
+https: function firstFunction(callback) {
   setTimeout(function () {
     console.log("First function executed.");
     callback();

25_asynchronous_javascript/5_promise/executor_function.md

@@ -0,0 +1,40 @@
+# Executor Function
+
+What
+
+- The executor function is a special function passed to the Promise constructor when creating a new Promise object.
+- It's responsible for initiating the asynchronous operation and determining whether the Promise should be resolved or rejected.
+
+Why
+
+- The executor function is crucial because it sets up the conditions for the Promise's outcome.
+- It typically contains the code that performs the asynchronous task and decides whether the task was successful or failed.
+
+How
+
+- Arguments: The executor function receives two functions as arguments: resolve and reject.
+- Asynchronous Operation: Inside the executor, you perform the asynchronous task.
+- Resolution or Rejection:
+  - If the task is successful, call the resolve function with the result as an argument. This fulfills the Promise.
+  - If the task fails, call the reject function with an error object as an argument. This rejects the Promise.
+
+Example
+
+```javascript
+const myPromise = new Promise((resolve, reject) => {
+  setTimeout(() => {
+    const data = { name: "John Doe", age: 30 };
+    resolve(data); // Fulfilling the Promise
+  }, 2000);
+});
+```
+
+Note
+
+- The executor function is called immediately when the Promise is created.
+- The asynchronous operation within the executor should be performed using asynchronous APIs or techniques (e.g., setTimeout, fetch, XMLHttpRequest).
+- The resolve and reject functions should only be called once within the executor.
+
+Analogy
+
+- Think of the executor function as a worker who is tasked with completing a job. The worker performs the job, and then either reports success (resolves the Promise) or failure (rejects the Promise).

25_asynchronous_javascript/5_promise/promise.js

@@ -14,22 +14,64 @@
 // - Pending: Initial state, neither fulfilled nor rejected.
 // - Fulfilled: The operation completed successfully.
 // - Rejected: The operation failed.
-// - You create a Promise using the Promise constructor, which takes an executor function as an argument. The executor function receives two functions: resolve and reject. You call resolve when the operation is successful, passing the result as an argument. You call reject when the operation fails, passing the error as an argument.
+// - You create a Promise using the Promise constructor, which takes an executor function as an argument.
+// - The executor function receives two functions: resolve and reject.
+// - You call resolve when the operation is successful, passing the result as an argument.You call reject when the operation fails, passing the error as an argument.
 
 // Syntax
-// const promise = new Promise((resolve, reject) => {
-//   // Asynchronous operation here
-//   if (/* condition for success */) {
-//     resolve(value);
-//   } else {
-//     reject(error);
-//   }
-// });
 
-// Example: 1
+// Basic Promise Creation
+const myPromise = new Promise((resolve, reject) => {
+  // Asynchronous operation
+  // If successful:
+  resolve(result);
+  // If unsuccessful:
+  reject(error);
+});
+
+// Chaining Promise
+myPromise
+  .then((result) => {
+    // Handle successful result
+    return anotherPromise; // Return another Promise for chaining
+  })
+  .then((result2) => {
+    // Handle result from the second Promise
+  })
+  .catch((error) => {
+    // Handle errors from any of the Promises
+  });
+
+// Error Handling
+myPromise
+  .then((result) => {
+    // Handle successful result
+  })
+  .catch((error) => {
+    // Handle errors
+  });
+
+// Promise.all()
+Promise.all([promise1, promise2, promise3])
+  .then((results) => {
+    // Handle successful results
+  })
+  .catch((error) => {
+    // Handle errors from all Promises
+  });
+
+// Promise.race()
+Promise.race([promise1, promise2, promise3])
+  .then((result) => {
+    // Handle the result from the first Promise that resolves
+  })
+  .catch((error) => {
+    // Handle errors
+  });
+
+// Example
 const promise1 = new Promise(function (resolve, reject) {
-  // Do async task
-  // Database call, cryptography, network
+  // Do async task like a database call, cryptography & network etc.
 
   setTimeout(function () {
     console.log("Async task is complete");

2_output/console_table.js

@@ -31,6 +31,15 @@ const students = [
 
 console.table(students);
 
+// Example: 3
+const object = {
+  key1: "value1",
+  key2: "value2",
+  key3: "value3",
+};
+
+console.table(object);
+
 // Note
 // - console.table() is a helpful debugging tool, but it should not be used for logging or displaying data in a production environment.
 

4_variable/1_variable.js

@@ -27,3 +27,8 @@ variable3 = variable4 = variable5 = 1;
 let variable6 = 1,
   variable7 = 2,
   variable8 = 3;
+
+// Note
+// - The fact that whenever we declare a variable and assign a value to it, it’s not the variable that holds the value but rather the variable just holds an address in the memory where the initialized value is stored. Further explaining, take for example:
+let age = 21;
+// - when we use age, it gets replaced with 21, but that does not mean that age contains 21, rather what it means is that the variable age contains the address of the memory location where 21 is stored.

README.md

@@ -166,6 +166,7 @@
     5. JavaScript Engine
     6. JavaScript Environment
     7. Just in time compilation (JIT)
+    8. Call Stack
 
 12. JavaScript Execution Context
 
@@ -179,11 +180,12 @@
 13. Asynchronous JavaScript
     1. Asynchronous Operations
     2. setTimeout & setInterval
-    3. Async and Await
-    4. Call back
+    3. Call back
        1. Call back function
        2. Call back hell
+    4. Async and Await
     5. Promise
+       1. Executor Function
     6. Fetch
 
 <!-- OOP -->

code_test_space.js

@@ -28,13 +28,15 @@
 
 // // promise1;
 
-function myFirst() {
-  console.log("Hello");
-}
-
-function mySecond() {
-  console.log("Goodbye");
-}
-
-mySecond(); 
-myFirst();
+const object = {
+  key1: "value1",
+  key2: "value2",
+  key3: "value3",
+  nestedObject: {
+    key4: "value4",
+    key5: "value5",
+    key6: "value6",
+  },
+};
+
+console.table(object);

javascript_under_the_hood/compile_time.md

@@ -1,26 +1,33 @@
 Compile Time
 
-**Compile Time**
+Compile Time
+
+What
+
+- Compile time refers to the phase in software development where source code is converted into a machine-readable format. This process is typically performed by a compiler.
+
+Why
 
-### What
-Compile time refers to the phase in software development where source code is converted into a machine-readable format. This process is typically performed by a compiler.
+- Compiling code offers several advantages:
 
-### Why
-Compiling code offers several advantages:
-* **Performance:** Compiled code can execute faster than interpreted code.
-* **Efficiency:** Compilers can optimize code for specific hardware and architectures.
-* **Portability:** Compiled code can be run on different platforms without needing the original source code.
+- **Performance:** Compiled code can execute faster than interpreted code.
+- **Efficiency:** Compilers can optimize code for specific hardware and architectures.
+- **Portability:** Compiled code can be run on different platforms without needing the original source code.
 
 ### How
+
 1. **Parsing:** The compiler breaks down the source code into tokens and analyzes its syntax.
 2. **Semantic Analysis:** The compiler checks the code for semantic errors, such as type mismatches or undefined variables.
 3. **Code Generation:** The compiler generates machine code or an intermediate representation that can be executed by a virtual machine or interpreter.
 
 ### Example
+
 In languages like C++, Java, and C#, the compilation process generates executable files that can be run directly on the target platform.
 
 ### Important Note
+
 Not all languages are compiled. Some languages, like JavaScript, are interpreted, meaning the code is executed directly without a compilation step. However, modern JavaScript engines often use Just-In-Time (JIT) compilation to improve performance.
 
 ### Analogy
+
 Think of a compiler as a translator who converts a book written in one language (the source code) into another language (machine code) that can be understood by the target audience (the computer).

javascript_under_the_hood/runt_time.md

@@ -1,7 +1,7 @@
-**Runtime**
+Runtime
 
-### What
-Runtime refers to the period during which a computer program is executing. It's the time when the code is being processed and instructions are carried out.
+What
+- Runtime refers to the period during which a computer program is executing. It's the time when the code is being processed and instructions are carried out.
 
 ### Why
 Understanding runtime is crucial for:

pending_concept/notes/terms_explain.md

@@ -120,6 +120,12 @@ Function == Method == Operations == Behaviors
 
 - Functions used to create new objects.
 
+# What is Prase?
+- Parsing is the process of taking a JSON string (which is essentially a text format) and converting it into a data structure that your programming language can use (e.g., an object or dictionary).
+
+# What is Serializes? 
+- In computing, serialization is the process of translating a data structure or object state into a format that can be stored or transmitted and reconstructed later.
+
 # Types of Naming Convention
 
 1. Camel Case: helloWorld