feat: add map vs filter

Author: brijeshkumar-chavda

11_array/array_method/Map.js

@@ -0,0 +1,46 @@
+// `map()`
+
+// What
+// - .map() is a built-in method for arrays in JavaScript. It creates a new array by applying a function to all elements of the original array.
+// - It transforms each element in the original array based on the provided function, giving you a new array with the results.
+
+// Why
+// - It offers a concise and efficient way to perform the same operation on every element in an array, creating a new transformed array.
+// - It avoids repetitive code for iterating through an array and modifying each element individually.
+
+// How
+// - You provide a callback function to .map(). This function is called for each element in the original array.
+// - The callback function takes three arguments (though the last two are optional):
+// - currentValue: The current element being processed in the iteration.
+// - index (optional): The index of the current element (if needed).
+// - array (optional): The original array being iterated over (if needed).
+// - The callback function should return a value that will be included in the new array.
+
+// Syntax
+// const newArray = originalArray.map(callbackFunction);
+
+// Example
+const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const newNumbers = array.map((number) => number < 10);
+console.log(newNumbers);
+
+// EXAMPLE
+const array1 = [
+  {
+    key1: "value1",
+    key2: "value2",
+    key3: "value3",
+    sameKey: "same value",
+  },
+  {
+    key4: "value4",
+    key5: "value5",
+    key6: "value6",
+    sameKey: "same value",
+  },
+];
+
+const newArray3 = array1.map((object) => {
+  return object.sameKey;
+});
+console.log(newArray3);

19_Iterations/9_map.js

@@ -33,6 +33,29 @@ Cons
 | - It store data in linear form.     | - It store data in `key : value` form.                                |
 |                                     | - It has size property.                                               |
 
+# .map() VS .filter()
+
+| Feature                      | `filter`                                                        | `map`                                                                       |
+| ---------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| **Purpose**                  | Filter elements based on a condition                            | Transform elements and create a new array                                   |
+| **Callback function output** | `true` or `false` (includes/excludes)                           | A value to be included in the new array                                     |
+| **New array elements**       | Only elements for which `true` is returned                      | Transformed values from the callback function                               |
+| **Modifies original array**  | No                                                              | No (creates a new array)                                                    |
+| **Side effects**             | Can be used for actions within the loop (e.g., logging)         | May have side effects within the loop (e.g., modifying temporary variables) |
+| **Functional approach**      | More functional, focuses on filtering logic                     | More functional, focuses on transformation logic                            |
+| **Common use cases**         | - Finding specific elements                                     | - Doubling numbers                                                          |
+|                              | - Removing elements from an array                               | - Converting strings to uppercase                                           |
+|                              | - Selecting objects based on properties                         | - Creating a new array with specific calculations                           |
+| **Example (numbers array)**  | Filter even numbers                                             | Double each number                                                          |
+| **Callback function**        | `number % 2 === 0` (even)                                       | `number * 2` (double)                                                       |
+| **Chaining**                 | Can be chained with `map` for filtering and then transformation | Can be chained with `filter` for additional filtering after transformation  |
+
+**Additional Notes:**
+
+- Both `filter` and `map` are non-mutating methods, meaning they don't modify the original array. They create a new array with the filtered or transformed elements.
+- While `filter` is generally considered more functional due to its focus on filtering logic, `map` can also be used functionally when the transformations are pure (without side effects).
+- When choosing between `filter` and `map`, consider your desired outcome: filtering elements based on a condition (`filter`) or creating a new array with transformed elements (`map`).
+
 # Iteration
 
 1. For Iterating Array