add asynchronous operation

Author: brijeshkumar-chavda

13_function/3_array_with_function.js

@@ -6,7 +6,7 @@ function handleArray(getArray) {
   return getArray[1];
 }
 
-// // Passing an array reference as a argument in the function.
+// Passing an array reference as a argument in the function.
 console.log(handleArray(myArray));
 
 // Passing literally an array as a argument in the function.

19_Iterations/6_for_in_loop.js

@@ -8,6 +8,7 @@
 // Why
 // - It can be useful for generic object property iteration, especially when you need to access property names and values for various purposes.
 // - It can simplify looping through object properties without requiring manual property access by name.
+
 // How
 // - It works by cycling through the enumerable properties of an object, one by one.
 // - The loop body executes for each property, providing you with the property name (prop) in each iteration.

25_asynchronous_javascript/asynchronous_diagram.png 25_asynchronous_javascript/01_asynchronous_operation/asynchronous_diagram.png

@@ -0,0 +1,31 @@
+# Asynchronous Operation
+
+What
+
+- An asynchronous operation is a process that starts but doesn't necessarily finish immediately.
+- It allows a program to continue executing other tasks while waiting for the operation to complete.
+
+Why
+
+- **Improved Performance:** Prevents the program from freezing while waiting for long-running tasks.
+- **Better User Experience:** Maintains responsiveness and allows users to interact with the application while background tasks are in progress.
+- **Efficient Resource Utilization:** Enables handling multiple tasks concurrently.
+
+How
+
+- When an asynchronous operation starts, it runs in the background. The program can continue executing other code while the operation is in progress.
+- Once the operation completes, a callback function or a promise is used to handle the result.
+
+Example
+
+- Fetching data from a server is a common asynchronous operation.
+- The code can continue executing other tasks while waiting for the data to be retrieved.
+- Once the data is available, a callback function is called to process it.
+
+Important Note
+
+- Asynchronous programming can introduce complexities like callbacks, promises, or async/await. Careful handling is required to manage asynchronous code effectively.
+
+When
+
+- Use asynchronous operations for tasks that are time-consuming or might block the program's execution, such as network requests, file I/O, or database operations.

25_asynchronous_javascript/01_asynchronous_operation/asynchronous_operation.md

@@ -0,0 +1,47 @@
+// Object
+
+// Resource
+
+// What
+// - Object is a data type in JavaScript that represents a complex data structure, such as arrays, functions, and custom objects.
+
+// Why
+// - Objects help organize and structure data in a more flexible and efficient manner.
+// - They provide a way to encapsulate related properties and methods into a single entity.
+// - Objects enable the creation of reusable code and modular programming.
+
+// How
+// - Objects are key-value pairs, where keys are unique identifiers and values can be of any data type.
+// - Objects can be created using object literals, constructor functions, or object-oriented programming techniques.
+
+// Syntax
+// Object literal syntax
+const object = {
+  key1: value1,
+  key2: value2,
+};
+
+// Constructor function syntax
+function MyObject() {
+  this.key1 = value1;
+  this.key2 = value2;
+}
+
+const object1 = new MyObject();
+
+// Example
+const person = {
+  name: "John",
+  age: 30,
+  greet: function () {
+    console.log(`Hello, my name is ${this.name}`);
+  },
+};
+
+console.log(person.name); // Output: John
+console.log(person.age); // Output: 30
+person.greet(); // Output: Hello, my name is John
+
+// Note
+// - Objects are mutable, meaning their properties and methods can be changed after they are created.
+

5_datatype/2_number.js 5_datatype/1_primitive_datatypes/1_number.js

@@ -0,0 +1,37 @@
+// Array
+
+// Resource
+
+// What
+// - Array is a data type in JavaScript that represents a collection of elements, also known as a list or a sequence.
+
+// Why
+// - Arrays provide a convenient way to store and organize multiple values in a single variable.
+// - They allow for efficient access, manipulation, and iteration over the elements.
+// - Arrays enable the creation of dynamic and flexible data structures.
+
+// How
+// - Arrays are ordered collections of elements, where each element has a unique index.
+// - The index starts from 0 and can be used to access and modify elements in the array.
+// - Arrays can contain elements of any data type, including other arrays, objects, and functions.
+
+// Syntax
+// Array literal syntax
+const array = [element1, element2, element3];
+
+// Array constructor syntax
+const array1 = new Array(element1, element2, element3);
+
+// Example
+const numbers = [1, 2, 3, 4, 5];
+console.log(numbers[0]); // Output: 1
+console.log(numbers[2]); // Output: 3
+
+numbers[3] = 10;
+console.log(numbers); // Output: [1, 2, 3, 10, 5]
+
+console.log(numbers.length); // Output: 5
+
+// Note
+// - Arrays are mutable, meaning their elements can be changed after they are created.
+// - Arrays can be dynamically resized, allowing you to add or remove elements.

5_datatype/4_string.js 5_datatype/1_primitive_datatypes/2_string.js

@@ -0,0 +1,44 @@
+// Topic
+
+// Resource
+// What
+// - Function is a reusable block of code that performs a specific task or calculates a value.
+
+// Why
+// - Functions help break down a program into smaller, more manageable pieces.
+// - They allow for code reuse, reducing redundancy and improving code readability.
+// - Functions enable modular programming, making it easier to maintain and debug code.
+
+// How
+// - Functions are defined using the function keyword, followed by the function name and a set of parentheses.
+// - Inside the function, you can write code to perform the desired task or calculate a value.
+// - Functions can accept parameters, which are values passed into the function when it is called.
+// - Functions can return a value using the return statement.
+
+// Syntax
+// Function Declaration
+function functionName(parameter1, parameter2) {
+  return console.log("I am Function Declaration");
+}
+
+// Function Expression
+const functionName = function (parameter1, parameter2) {
+  return console.log("I am Function Expression");
+};
+
+// Example
+function greet(name) {
+  console.log(`Hello, ${name}!`);
+}
+
+greet("John"); // Output: Hello, John!
+
+function add(a, b) {
+  return a + b;
+}
+
+const result = add(2, 3);
+console.log(result); // Output: 5
+
+// Note
+// - Functions in JavaScript are first-class objects, meaning they can be assigned to variables, passed as arguments to other functions, and returned as values from functions.

5_datatype/5_boolean.js 5_datatype/1_primitive_datatypes/3_boolean.js

@@ -0,0 +1,22 @@
+// `undefined`
+
+// Resource
+
+// What
+// -> Undefined is a data type in JavaScript that represents a variable that has not been assigned a value.
+
+// Why
+// -> Undefined helps ensure that your program behaves correctly and handles different types of data appropriately.
+// -> It provides a foundation for writing robust and maintainable code.
+
+// How
+// -> You can assign literally a value as undefined to a variable.
+// -> Declared variables without assigning any value also have an undefined value.
+
+// Syntax
+let variableName1; // variable declared but not assigned any value
+let variableName2 = undefined; // variable assigned the value `undefined`
+
+// Note
+// -> It is not recommended to explicitly assign the value undefined to a variable.
+

5_datatype/6_symbol/1_symbol.js 5_datatype/1_primitive_datatypes/4_symbol/1_symbol.js

@@ -0,0 +1,21 @@
+// `null`
+
+// What
+// -> Null is standalone value. To understand this let say you are creating weather application which give you the temperature of selected city. For any reason server unable to send you the temperature that means there is no temperature value. At that case weather app shouldn't show `0` on screen. Because 0 also refer as temperature value. At that time we use null to show there is actually no temperature and server are unable to fetch data of temperature.
+
+// Why
+// -> Null helps handle cases where a variable should have a value, but the value is currently not available or not applicable.
+// -> It provides a way to differentiate between an unassigned variable and a variable with a value of null.
+
+// How
+// -> Null is a standalone value. It represents the absence of a value.
+// -> When checking the type of null using typeof, it will show object. This is a common misconception, as null is not an object.
+
+// Syntax
+let variableName = null;
+
+// Note
+// -> Null is often used to represent the absence of a value, such as when a function does not return a value or when an object is expected but not available.
+
+// When
+// -> Use Null when you want to represent the absence of a value or when a variable should have a value of null.

5_datatype/6_symbol/2_symbol_cant_use_dot_operator.md 5_datatype/1_primitive_datatypes/4_symbol/2_symbol_cant_use_dot_operator.md

@@ -17,17 +17,6 @@
 // - Undefined: Represents a variable that has not been assigned a value.
 // - Null: Represents a variable that has been explicitly assigned a value of null.
 
-// Undefined
-// - You can assign literally a value as a `undefined`
-let undefined1 = undefined;
-// - Declared variable which doesn't assigned any value yet also has undefined as a value.
-let undefined2;
-
-// Null
-// - Null is standalone value. To understand this let say you are creating weather application which give you the temperature of selected city. For any reason server unable to send you the temperature that means there is no temperature value. At that case weather app shouldn't show `0` on screen. Because 0 also refer as temperature value. At that time we use null to show there is actually no temperature and server are unable to fetch data of temperature.
-// - WHEN CHECK THE TYPEOF NULL IT WILL SHOW IT IS AN OBJECT.
-let myNull = null;
-
 // Non-Primitive Data Types (Reference, Complex)
 
 // Object

5_datatype/2_non_primitive_datatypes/1_object.js

@@ -28,9 +28,19 @@
 
 5. Datatype
 
-   1. Types Of Datatype
-   2. Symbol
-   3. NaN
+   1. Primitive Data Type
+      1. Number
+      2. String
+      3. Boolean
+      4. Symbol
+   2. Non-Primitive Data Type
+      1. Object
+      2. Array
+      3. Function
+   3. Stand Alone Values
+      1. NaN
+      2. Undefined
+      3. Null
    4. Type Conversion
    5. Primitive & Non-Primitive Datatype
 
@@ -160,32 +170,24 @@
 
 # Monospace Font
 
-1. MonoLisa
-2. Fira Mono
+1. Fira Mono Light
+2. JetBrains Mono ExtraLight
 3. Commit Mono
-4. Cascadia Code
-5. JetBrains Mono
+4. Fira Mono
+5. Monaspace
+6. MonoLisa
+7. Source Code Pro
+8. Cascadia Code
+9. JetBrains Mono
+10. Maple Mono
 
 # Theme - Pitch Dark Background
 
-1. Monokai Night
-2. Night Owl
-3. Noctis - Obscuro
-4. Ayu - Dark
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+1. Bluloco
+2. Dracula
+3. Github dark
+4. One Dark Mono
+5. Ayu - Dark
+6. Noctis - Obscuro
+7. Monokai Night
+8. Night Owl