segregated files with topics

Author: Mayur Kadam

Diff for: .DS_Store

@@ -0,0 +1,155 @@
+# JavaScript Iterators and Iterables
+
+**Full Article:** [Iterators and Iterables](https://medium.com/mighty-ghost-hack/js-interview-10-iterators-and-iterables-227827118b20)
+
+## 🔹 Introduction
+In JavaScript, **iterables** are objects that implement the **`Symbol.iterator`** method, making them compatible with iteration protocols. **Iterators** are objects that define a **`next()`** method, which returns an object with `{ value, done }` properties.
+
+---
+
+## 📌 Iterables in JavaScript
+An **iterable** is an object that provides a way to iterate over its elements using a loop. Common iterables include:
+
+- Arrays
+- Strings
+- Maps
+- Sets
+
+### ✅ Example: Built-in Iterables
+```js
+const arr = [1, 2, 3];
+for (let num of arr) {
+    console.log(num);
+}
+// Output: 1, 2, 3
+```
+
+### ✅ Checking If an Object Is Iterable
+```js
+console.log(typeof arr[Symbol.iterator]); // Output: function
+```
+
+---
+
+## 📌 Iterators in JavaScript
+An **iterator** is an object with a **`next()`** method that returns `{ value, done }`:
+
+### ✅ Example: Creating an Iterator Manually
+```js
+function createIterator(arr) {
+    let index = 0;
+    return {
+        next: function() {
+            return index < arr.length
+                ? { value: arr[index++], done: false }
+                : { value: undefined, done: true };
+        }
+    };
+}
+
+const iterator = createIterator(["a", "b", "c"]);
+console.log(iterator.next()); // { value: "a", done: false }
+console.log(iterator.next()); // { value: "b", done: false }
+console.log(iterator.next()); // { value: "c", done: false }
+console.log(iterator.next()); // { value: undefined, done: true }
+```
+
+---
+
+## 📌 Custom Iterable Objects
+You can make any object iterable by implementing the **`Symbol.iterator`** method:
+
+### ✅ Example: Custom Iterable Object
+```js
+const myIterable = {
+    data: [10, 20, 30],
+    [Symbol.iterator]: function() {
+        let index = 0;
+        return {
+            next: () => {
+                return index < this.data.length
+                    ? { value: this.data[index++], done: false }
+                    : { done: true };
+            }
+        };
+    }
+};
+
+for (let value of myIterable) {
+    console.log(value);
+}
+// Output: 10, 20, 30
+```
+
+---
+
+## 📌 Generators as Iterators
+**Generators** simplify iterator creation using the `function*` syntax:
+
+### ✅ Example: Generator Function
+```js
+function* generatorFunc() {
+    yield 1;
+    yield 2;
+    yield 3;
+}
+
+const gen = generatorFunc();
+console.log(gen.next()); // { value: 1, done: false }
+console.log(gen.next()); // { value: 2, done: false }
+console.log(gen.next()); // { value: 3, done: false }
+console.log(gen.next()); // { value: undefined, done: true }
+```
+
+---
+
+## 📌 Practical Use Cases
+✅ **Iterating Over Data**
+```js
+const set = new Set(["apple", "banana", "cherry"]);
+for (let item of set) {
+    console.log(item);
+}
+// Output: apple, banana, cherry
+```
+
+✅ **Spreading Iterables**
+```js
+const str = "hello";
+const letters = [...str];
+console.log(letters); // [ 'h', 'e', 'l', 'l', 'o' ]
+```
+
+✅ **Custom Range Iterator**
+```js
+function range(start, end) {
+    return {
+        [Symbol.iterator]: function() {
+            let current = start;
+            return {
+                next: () => {
+                    return current <= end
+                        ? { value: current++, done: false }
+                        : { done: true };
+                }
+            };
+        }
+    };
+}
+
+for (let num of range(1, 5)) {
+    console.log(num);
+}
+// Output: 1, 2, 3, 4, 5
+```
+
+---
+
+## 🔹 Summary
+- **Iterables** implement `Symbol.iterator`.
+- **Iterators** have a `next()` method returning `{ value, done }`.
+- **Generators** simplify iteration.
+- Iterables allow use in `for...of`, spreading (`...`), and `Array.from()`.
+
+🚀 **Mastering iterators and iterables helps in handling asynchronous data and optimizing JavaScript performance!**
+

Diff for: 01 - JavaScript & TypeScript Basic/.DS_Store

@@ -0,0 +1,112 @@
+# Introduction to JavaScript NaN
+
+**Full Article:** [JavaScript NaN](https://medium.com/mighty-ghost-hack/js-interview-6-introduction-to-javascript-nan-d6b1a441e7a8)
+
+## What is `NaN`?
+`NaN` stands for **Not-a-Number**. It is a special value in JavaScript that represents an invalid number or an unrepresentable mathematical operation.
+
+```javascript
+console.log(typeof NaN); // "number"
+```
+Even though `NaN` means "Not-a-Number," its type is still `number` in JavaScript.
+
+---
+
+## When does `NaN` occur?
+### 1️⃣ Invalid Mathematical Operations
+```javascript
+console.log(0 / 0); // NaN
+console.log(Infinity - Infinity); // NaN
+console.log(Math.sqrt(-1)); // NaN
+```
+
+### 2️⃣ Attempting to Convert Non-Numeric Values
+```javascript
+console.log(parseInt("hello")); // NaN
+console.log(Number("world")); // NaN
+console.log(5 * "abc"); // NaN
+```
+
+### 3️⃣ Operations with `undefined`
+```javascript
+let x;
+console.log(x + 2); // NaN
+```
+
+---
+
+## How to Check for `NaN`?
+### 1️⃣ Using `isNaN()` (Global Function)
+```javascript
+console.log(isNaN("hello")); // true
+console.log(isNaN(42)); // false
+console.log(isNaN(NaN)); // true
+```
+🔹 **Caution:** `isNaN()` performs type coercion, which may lead to unexpected results.
+```javascript
+console.log(isNaN("123")); // false ("123" is converted to a number)
+console.log(isNaN("123abc")); // true (cannot fully convert)
+```
+
+### 2️⃣ Using `Number.isNaN()` (Safer Approach)
+```javascript
+console.log(Number.isNaN(NaN)); // true
+console.log(Number.isNaN("hello")); // false
+console.log(Number.isNaN(42)); // false
+```
+✅ `Number.isNaN()` does **not** perform type coercion, making it a more reliable check.
+
+---
+
+## `NaN` Behavior in Arithmetic Operations
+### 1️⃣ Propagation of `NaN`
+Once `NaN` appears in an operation, it usually propagates:
+```javascript
+console.log(NaN + 5); // NaN
+console.log(NaN * 10); // NaN
+```
+
+### 2️⃣ `NaN` is Not Equal to Itself
+```javascript
+console.log(NaN === NaN); // false
+```
+🔹 This is because `NaN` is **not** equal to anything, even itself!
+
+To check for `NaN`, use:
+```javascript
+console.log(Object.is(NaN, NaN)); // true
+```
+
+---
+
+## Fixing `NaN` Issues
+### 1️⃣ Provide Default Values with `||` or `??`
+```javascript
+let result = NaN || 0; // 0 (using OR operator)
+let safeValue = NaN ?? 10; // 10 (Nullish coalescing operator, works only for null & undefined)
+```
+
+### 2️⃣ Validate Input Before Performing Operations
+```javascript
+function safeDivide(a, b) {
+    if (typeof a !== "number" || typeof b !== "number" || b === 0) {
+        return "Invalid Operation";
+    }
+    return a / b;
+}
+
+console.log(safeDivide(10, 2)); // 5
+console.log(safeDivide(10, 0)); // "Invalid Operation"
+console.log(safeDivide(10, "hello")); // "Invalid Operation"
+```
+
+---
+
+## Summary
+- `NaN` stands for "Not-a-Number" and occurs due to invalid math operations or failed conversions.
+- `isNaN()` is **not** always reliable due to type coercion; prefer `Number.isNaN()`.
+- `NaN` is **not equal** to itself, making direct comparisons unreliable.
+-  Use proper validation and default values to prevent `NaN` issues in code.
+
+🚀 **Understanding `NaN` helps in writing more robust JavaScript applications!**
+