05. Type Coercion, Equality Quirks (== vs ===, NaN & Object.is) • JavaScript & Advanced ES6+ (0-to-Hero Big Tech Standard) • Rishabh Ki Kaksha

Jab JavaScript do alag datatypes ke beech operation karte waqt ek type ko **automatically (chupke se)** dusre type me badal deti hai, use **Type Coercion** kehte hain.

*   **Implicit Coercion (Automatic):** JS khud karti hai (e.g. `1 + "2" = "12"`).
*   **Explicit Coercion (Manual):** Developer khud karta hai (e.g. `Number("42")` ya `String(10)`).

---

### 2. The Plus (+) vs Minus (-) Operator Magic

1.  **Plus (`+`) Operator ke 2 chehre hain:**
    *   Agar ek bhi operand **String** hai, toh JS sabko String bana ke **Concatenate (Jod)** deti hai!
    ```javascript
    "5" + 2      // "52"
    1 + 2 + "3"  // "33" (Pehle 1+2=3, fir 3+"3"="33")
    "1" + 2 + 3  // "123"
    ```
2.  **Minus (`-`), Multiply (`*`), Divide (`/`) Sirf Math jante hain:**
    *   Ye Strings ko **Number** me convert karke mathematically solve karte hain!
    ```javascript
    "5" - 2      // 3
    "10" * "2"   // 20
    "6" / "2"    // 3
    "hello" - 2  // NaN (Not a Number)
    ```

---

### 3. Truthy vs Falsy Values

JavaScript me if-condition me check karte waqt har value ya to Truthy hoti hai ya Falsy.

#### Sirf 8 Falsy Values Hoti Hain (Baqi Sab Truthy Hai!):
1.  `false`
2.  `0`
3.  `-0`
4.  `0n` (BigInt zero)
5.  `""` (Empty string)
6.  `null`
7.  `undefined`
8.  `NaN`

> **Note:** `[]` (Empty Array) aur `{}` (Empty Object) **Truthy** hote hain!

---

### 4. Equality Operators: `==` vs `===` vs `Object.is()`

#### A) Loose Equality (`==`)
*   Types check nahi karta.
*   Pehle Coercion (type conversion) karta hai, fir compare karta hai.
```javascript
5 == "5"       // true
0 == false     // true (false -> 0)
null == undefined // true
```

#### B) Strict Equality (`===`)
*   Type aur Value dono check karta hai bina kisi conversion ke.
```javascript
5 === "5"      // false
0 === false    // false
null === undefined // false
```

#### C) `Object.is()` - The Perfectionist (ES6)
`===` me 2 chhota bug/quirk tha jise `Object.is()` ne fix kiya:
1.  `NaN === NaN` is `false` (Lekin `Object.is(NaN, NaN)` is **`true`**).
2.  `+0 === -0` is `true` (Lekin `Object.is(+0, -0)` is **`false`**).

---

### 5. Famous Weird JS Expression: Why `[] == ![]` is `true`?

Ye interview ka sabse famous question hai. Step-by-step dekhte hain JS kya karti hai:
1.  `![]`: `[]` Truthy hai, to `![]` ban gaya `false`.
2.  Ab equation hai: `[] == false`.
3.  Rule: Boolean `false` convert hua number `0` me -> `[] == 0`.
4.  Rule: Object `[]` convert hua string `""` me -> `"" == 0`.
5.  Rule: String `""` convert hua number `0` me -> `0 == 0`.
6.  `0 === 0` -> **`true`**! 🎉

---

### 6. Comparison Table

| Expression | Result | Reason |
| :--- | :--- | :--- |
| `[] + []` | `""` | Dono empty string me convert huye |
| `[] + {}` | `"[object Object]"` | Array empty string bana, Object string bana |
| `true + true` | `2` | `1 + 1 = 2` |
| `typeof NaN` | `"number"` | Numeric type ka invalid mathematical result |
| `NaN === NaN` | `false` | IEEE 754 standard rule |

---

### 7. Interview Ke 4 Sawal Is Topic Se

1.  **`==` aur `===` me kab kaunsa use karna chahiye?** -> Hamesha `===` use karo taki unexpected coercion bugs na aayein.
2.  **`NaN` check karne ka sahi tarika kya hai?** -> `Number.isNaN(x)` use karo (Kyunki `x === NaN` hamesha false deta hai).
3.  **`"10" + 20` aur `"10" - 20` ka output kya hoga?** -> `"10" + 20 = "1020"` (Concatenation). `"10" - 20 = -10` (Math subtraction).
4.  **`Object.is()` kab zaroori hota hai?** -> React state equality checking me (React use karta hai taaki `NaN` updates accurately handle hon aur `+0`/`-0` correctly detect hon).

---
**Next Topic:** Module 2: V8 Engine Internals & Execution Context Architecture

Loading lesson content...

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track