Merge branch 'master' into javascript

Author: Gunashekar31742

README.md

@@ -506,8 +506,11 @@
 | 475 | [What are shadowing and illegal shadowing?](#what-are-shadowing-and-illegal-shadowing) |
 | 476 | [Why is it important to remove event listeners after use?](#why-is-it-important-to-remove-event-listeners-after-use) |
 | 477 | [What is structuredClone and how is it used for deep copying objects?](#what-is-structuredclone-and-how-is-it-used-for-deep-copying-objects) |
+
 | 477 | [What is the difference btw == & === in java script?](#what-is-structuredclone-operators) |
 
+| 478 | [What is the difference between const and Object.freeze](#what-is-the-difference-between-const-and-objectfreeze) |
+
 <!-- TOC_END -->
 
 <!-- QUESTIONS_START -->
@@ -9554,36 +9557,36 @@ Common use cases and benefits:
 
    **[⬆ Back to Top](#table-of-contents)**
 
-   479. ### What is the purpose of the at() method
+479. ### What is the purpose of the at() method
 
-       The `at()` method takes an integer value and returns the item at that index, allowing for positive and negative integers. Negative integers count back from the last item in the array or string.
+The `at()` method takes an integer value and returns the item at that index, allowing for positive and negative integers.
+Negative integers count back from the last item.
 
-       Prior to this method, accessing the last element of an array required using array[array.length - 1]. The at() method makes this much cleaner and supports both **Arrays** and **Strings**.
+Prior to this method, accessing the last element of an array required using array[array.length - 1].
+The at() method makes this much cleaner and supports both **Arrays** and **Strings**.
 
-         *Key Features:*
-         1. *Positive Index:* Works the same as square bracket notation [].
-         2. *Negative Index:* Counts from the end of the array (e.g., -1 is the last element).
+**Key Features:**
+1. *Positive Index:* Works the same as square bracket notation [].
+2. *Negative Index:* Counts from the end of the array (e.g., -1 is the last element).
 
-         **Example:**
+**Example:**
 
-         ```javascript
-         const colors = ["Red", "Green", "Blue"];
-         // Old way to get the last element
-         console.log(colors[colors.length - 1]); // "Blue"
+```javascript
+const colors = ["Red", "Green", "Blue"];
 
-         // Using at()
-         console.log(colors.at(-1)); // "Blue"
-         console.log(colors.at(-2)); // "Green"
+// Old way to get the last element
+console.log(colors[colors.length - 1]); // "Blue"
 
-         // It also works on Strings
-         const sentence = "Hello";
-         console.log(sentence.at(-1)); // "o"
+// Using at()
+console.log(colors.at(-1)); // "Blue"
+console.log(colors.at(-2)); // "Green"
 
-         // Comparing with bracket notation for negative index
-          console.log(colors[-1]); // undefined (Bracket notation looks for a property named "-1")
-         
+// It also works on Strings
+const sentence = "Hello";
+console.log(sentence.at(-1)); // "o"
 
-     **[⬆ Back to Top](#table-of-contents)**
+// Comparing with bracket notation for negative index
+console.log(colors[-1]); // undefined (Bracket notation looks for property "-1")
 
 <!-- QUESTIONS_END -->
 ### Coding Exercise

coding-exercise/deep-merge-nested-objects/README.md

@@ -0,0 +1,62 @@
+Deep-Merge Two Nested Objects (with Circular References)
+Challenge:
+Implement a deep-merge function that combines two nested JavaScript objects while safely handling circular references. The function must be immutable and able to merge objects, arrays, and nested structures.
+
+Problem Description:
+Deep merging means recursively combining the properties of two objects. When both inputs contain nested objects, arrays, or shared references, this becomes more complex.
+
+Your task is to:
+Merge all properties from both objects
+Recursively merge nested objects
+Merge arrays by index
+Avoid infinite recursion when circular references exist
+Return a new, immutable object
+Ensure values from the second object override the first when conflicts occur
+Real-World Use Case
+State management libraries (Redux, Zustand, Immer)
+Complex configuration merging
+Deep cloning with overrides
+Normalizing API responses
+Merging schema definitions
+
+Example:
+Input
+const a = { 
+    x: 1,
+    y: { z: 2 }
+};
+a.self = a; // circular reference
+
+const b = { 
+    y: { k: 20 },
+    m: 100
+};
+b.loop = b; // circular reference
+
+const result = deepMerge(a, b);
+
+Output
+{
+    x: 1,
+    y: { z: 2, k: 20 },
+    m: 100,
+    self: [circular],
+    loop: [circular]
+}
+
+Requirements:
+Must deep-merge nested objects and arrays
+Must detect and safely handle circular references
+Must not mutate inputs
+When both objects contain the same key:
+If both values are objects → recursively merge
+If both are arrays → merge by index
+Otherwise → value from second object overrides
+Must create a brand-new object as the output
+
+Key Concepts:
+Recursion
+WeakMap to track visited nodes
+Object and array cloning
+Circular reference detection
+Immutability principles

coding-exercise/deep-merge-nested-objects/question.md

@@ -0,0 +1,51 @@
+# Exercise: Deep-Merge Two Nested Objects (with Circular References)
+
+## Problem Statement
+
+Write a function **`deepMerge(objA, objB)`** that deeply merges two JavaScript objects **without mutating** either of them.  
+The function must correctly merge nested structures and safely handle circular references.
+
+---
+
+## Rules
+
+1. If a key exists only in one object → copy that value.
+2. If a key exists in both objects:
+   - If both values are **plain objects**, recursively merge them.
+   - If both values are **arrays**, merge by index (element-wise).
+   - Otherwise, the value from **`objB`** overrides the value from **`objA`**.
+3. Handle **circular references** using a tracking mechanism like **WeakMap**.
+4. Always return a **new**, immutable object.
+5. Must preserve structure even when circular references appear on both inputs.
+
+---
+
+## Example
+
+```js
+const a = {
+    x: { y: 1 },
+    arr: [1, 2]
+};
+a.self = a; // circular
+
+const b = {
+    x: { z: 2 },
+    arr: [3],
+    extra: true
+};
+b.loop = b; // circular
+
+const result = deepMerge(a, b);
+
+/*
+Expected structure:
+
+{
+  x: { y: 1, z: 2 },
+  arr: [1, 3],   // merged by index
+  extra: true,
+  self: <circular>,
+  loop: <circular>
+}
+*/

coding-exercise/deep-merge-nested-objects/solution.js

@@ -0,0 +1,50 @@
+/**
+ * Deeply merges two objects while safely handling circular references.
+ * Returns a new object without mutating the originals.
+ *
+ * @param {Object|Array} obj1
+ * @param {Object|Array} obj2
+ * @returns {Object|Array}
+ */
+function deepMerge(obj1, obj2, visited = new WeakMap()) {
+    // If obj2 is primitive, return it directly
+    if (obj2 === null || typeof obj2 !== "object") {
+        return obj2;
+    }
+
+    // Detect circular reference
+    if (visited.has(obj2)) {
+        return visited.get(obj2);
+    }
+
+    // Determine output type
+    const output = Array.isArray(obj1) ? [...obj1] :
+                   Array.isArray(obj2) ? [...obj2] :
+                   { ...obj1 };
+
+    visited.set(obj2, output);
+
+    for (const key in obj2) {
+        if (!obj2.hasOwnProperty(key)) continue;
+
+        const val1 = obj1 ? obj1[key] : undefined;
+        const val2 = obj2[key];
+
+        if (val1 !== undefined && typeof val1 === "object" && typeof val2 === "object") {
+            output[key] = deepMerge(val1, val2, visited);
+        } else {
+            output[key] = val2;
+        }
+    }
+
+    return output;
+}
+
+// Example usage
+const a = { x: 1, y: { z: 2 } };
+a.self = a;
+
+const b = { y: { k: 20 }, m: 100 };
+b.loop = b;
+
+console.log(deepMerge(a, b));