feat: add iterations

Author: brijeshkumar-chavda

loop/1_for_loop.js 19_Iterations/1_for_loop.js

@@ -1,12 +1,12 @@
-// Topic: For loop
+// `for` loop
 
-// Q. What is for loop?
+// What
 // - A for loop in JavaScript is a programming construct that allows you to repeat a set of instructions a certain number of times. It's great for automating tasks that need to be done repeatedly.
 
-// Q. Why use for loop?
+// Why
 // - Imagine you have a task you need to do over and over again. Instead of writing the same code multiple times, a for loop helps you perform that task a specific number of times, making your code more efficient and easier to manage.
 
-// Q. How for loop work?
+// How
 // - Initialization: You start by defining a variable and giving it an initial value. This variable will keep track of the loop's progress.
 // - Condition: You specify a condition that, as long as it's true, the loop will continue to run. This condition is checked before every loop iteration.
 // - Iteration: After each iteration of the loop, the loop variable is updated according to a certain pattern.
@@ -22,9 +22,48 @@
 // }
 
 // Example
-for (let i = 1; i <= 5; i++) {
-  console.log(i);
+for (let index = 0; index <= 10; index++) {
+  console.log(index);
 }
 
-// Summary
-// - A for loop in JavaScript helps you repeat a set of instructions a specific number of times. You provide an initial value, a condition to check before each iteration, and an iteration pattern. The loop runs as long as the condition is true. It's a useful tool for automating repetitive tasks and making your code more efficient. Just ensure your loop's condition eventually becomes false to avoid infinite loops.
+for (let index = 0; index <= 10; index++) {
+  if (index === 5) {
+    console.log("This is number 5");
+  }
+  console.log(index);
+}
+
+for (let i = 1; i <= 10; i++) {
+  // console.log(`Outer loop: ${i}`);
+  for (let j = 1; j <= 10; j++) {
+    // console.log(`Inner loop: ${j}`);
+    console.log(`${i} * ${j} = ${i * j}`);
+  }
+}
+
+// For loop for array
+const myArray = [0, 1, 2, 3, 4, 5];
+console.log(myArray);
+
+for (let index = 0; index < myArray.length; index++) {
+  const element = myArray[index];
+  console.log(element);
+}
+
+// Break
+for (let index = 0; index <= 10; index++) {
+  if (index === 5) {
+    console.log("Number 5 detected");
+    break;
+  }
+  console.log(index);
+}
+
+// Continue
+for (let index = 0; index <= 10; index++) {
+  if (index === 5) {
+    console.log("Number 5 detected");
+    continue;
+  }
+  console.log(index);
+}

19_Iterations/3_while_loop.js

@@ -0,0 +1,21 @@
+// While Loop
+
+// Syntax
+// Initialization
+// while (condition){
+//  Code...
+// Increment/ Decrement
+// }
+
+let index = 0;
+while (index <= 10) {
+  console.log(index);
+  index++;
+}
+
+let myArray = ["red", "green", "blue"];
+let i = 0;
+while (i < myArray.length) {
+  console.log(myArray[i]);
+  i++;
+}

loop/5_do_while_loop.js 19_Iterations/4_do_while_loop.js

@@ -1,14 +1,14 @@
 // Do While Loop
 
-// SYNTAX
+// Syntax
 // Initialization
 // do {
 //  Code...
 // Increment/ Decrement
 // } while (condition)
 
-let variable = 0;
+let index = 11;
 do {
-  console.log(variable);
-  variable++;
-} while (variable <= 10);
+  console.log(index);
+  index++;
+} while (index <= 10);

19_Iterations/5_for_of_loop.js

@@ -0,0 +1,67 @@
+// For of Loop
+
+// What
+// - for...of is a loop specifically designed to iterate over iterable objects in JavaScript.
+// - Iterable objects are those that can provide a sequence of values, such as arrays, strings, maps, sets, and some custom objects.
+
+// Why
+// - It offers a concise and readable way to iterate over the values of an iterable object, often used in modern JavaScript code.
+// - Compared to traditional for loops (with indices), it focuses on the values themselves, potentially improving code clarity.
+
+// - How
+// - It works by creating an iterator for the iterable object.
+// - An iterator is an object that provides a next() method, which returns the next element in the sequence along with a done property indicating whether the iteration is complete.
+// - The loop automatically iterates until there are no more values left (the done property becomes true).
+
+// Note
+// - The order of iteration is guaranteed.
+// - Not recommended to use on object.
+// - Unlike traditional for loops, for...of doesn't give you access to the current index directly. If you need the index, you can use a combination of for...of with a traditional for loop (nested or with an index counter).
+// - The for...of loop doesn't modify the original iterable object. It iterates over a copy of the values.
+
+// Syntax
+// for (const element of iterable_object) {
+//   // Code to be executed for each element
+// }
+
+// Example
+
+// For of loop on string
+const myString = "String";
+for (const character of myString) {
+  console.log(character);
+}
+
+// For of loop on array
+const array = [0, 1, 2, 3, 4, 5];
+
+for (const element of array) {
+  console.log(element);
+}
+
+// For of loop on Map()
+const myMap = new Map([
+  ["key1", "value1"],
+  ["key2", "value2"],
+  ["key3", "value3"],
+]);
+
+// for of -> Map -> key
+for (const key of myMap) {
+  console.log(key);
+}
+// for of -> Map -> [key, value] -> key | value
+for (const [key, value] of myMap) {
+  console.log(key);
+  console.log(value);
+}
+
+// For of loop on object (NOT RECOMMENDED)
+// Object.keys(objectName) -> key -> objectName[key] -> value
+const object = {
+  key1: "value1",
+  key2: "value2",
+};
+for (const key of Object.keys(object)) {
+  console.log(object[key]);
+}

19_Iterations/6_for_in_loop.js

@@ -0,0 +1,42 @@
+// `for in` Loop
+
+// What
+// - for...in is a loop specifically designed to iterate over the enumerable properties of an object in JavaScript.
+// - It provides a way to access all properties (including inherited ones) of an object, regardless of their type (strings, numbers, functions, etc.).
+// - It is use to iterate over the object property.
+
+// 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.
+// - You can then access the property value using the property name: object[key].
+
+// Note
+// - The order of iteration is not guaranteed.
+// - Not recommended to use on array.
+
+// Syntax
+// for (key in object){
+//   Code...
+// }
+
+// For in loop on object
+const object = {
+  key1: "value1",
+  key2: "value2",
+  key3: "value3",
+};
+
+for (let key in object) {
+  console.log(key);
+  console.log(object[key]);
+}
+
+// For in loop on array (NOT RECOMMENDED)
+const array = [1, 2, 3, 4, 5];
+for (const index in array) {
+  console.log(index);
+  console.log(array[index]);
+}

19_Iterations/7_for_each_loop.js

@@ -0,0 +1,49 @@
+// Map
+
+// What
+// - It is iterable.
+// - It store data in `[key, value]` form.
+// - Element insertion order is guaranteed.
+// - It can store duplicate value with different key. If you add same key in map it will take the last added key and update the value.
+// - It is a built-in object in JavaScript that stores key-value pairs. Unlike objects (which use strings or symbols as keys), Map allows you to use any data type (including objects) as keys.
+
+// Why
+// - It provides a more flexible and ordered way to store data compared to traditional objects.
+// - Map objects are particularly useful when you need to use non-string keys or when you want to maintain the insertion order of key-value pairs.
+
+// How
+// - You can create a Map object using the new Map() constructor or by providing an iterable of key-value pairs.
+// - You can add key-value pairs using the set() method and access values using the get() method.
+// - You can also check if a key exists using the has() method and remove a key-value pair using the delete() method.
+
+// SYNTAX
+// const map = new Map([
+//   ["key1", "value1"],
+//   ["key2", "value2"],
+//   ["key3", "value3"],
+// ]);
+
+// Using the constructor
+const myMap = new Map();
+
+// Using an iterable (array of key-value pairs)
+const anotherMap = new Map([
+  ["name", "Alice"],
+  [1, "one"],
+  [true, "boolean value"],
+]);
+
+// Adding key-value pair in Map()
+myMap.set("age", 30);
+myMap.set({}, "object key"); // Can use objects as keys
+
+// Accessing value
+const value = myMap.get("age"); // value will be 30
+
+// Checking for keys
+if (myMap.has("name")) {
+  console.log("Name exists in the map");
+}
+
+// Removing key-value pair
+myMap.delete("age");

20_map/1_map.js

@@ -0,0 +1,38 @@
+// Map Iterate
+
+const myMap = new Map(
+  ["key1", "value1"],
+  ["key2", "value2"],
+  ["key3", "value3"]
+);
+
+myMap.forEach(function (value, key, map) {
+  console.log(key + ": " + value);
+});
+
+// Iterable
+
+// Return values
+for (let key of myMap) {
+  console.log(key);
+}
+
+// Return keys and values
+// It's return key and value in array form.
+for (let [key, value] of myMap) {
+  console.log([key, value]);
+}
+
+// Using object as key
+const teachersDetail = {
+  id: "101",
+  name: "Math Teacher",
+};
+const extraTeachersDetail = new Map();
+extraTeachersDetail.set(teachersDetail, {
+  subject: "Math",
+  department: "Math Department",
+});
+console.log(teachersDetail.id);
+console.log(teachersDetail.name);
+console.log(extraTeachersDetail.get(teachersDetail).department);