# Why undefined == null is true but null == 0 is false?

## `undefined == null` → true, but `null == 0` → false (WHY?)

JavaScript equality is one of the most confusing topics for beginners.

Consider these three statements:

```javascript
undefined == null   // true 
undefined === null  // false 
null == 0           // false 
```

At first glance, all look like “empty values”… so why different results?

Let’s break this mystery step-by-step

---

## Step 1 — Understand `==` vs `===`

JavaScript has **two equality operators**:

| Operator | Name | Type Conversion |
| --- | --- | --- |
| `==` | Loose equality | Yes |
| `===` | Strict equality | No |

```javascript
1 == "1"   // true
1 === "1"  // false
```

---

## Step 2 — What is `undefined`?

`undefined` means:

> A variable is declared but not assigned a value.

```javascript
let a;
console.log(a); // undefined
```

It’s automatically assigned by JavaScript.

---

## Step 3 — What is `null`?

`null` means:

> An intentional empty value set by the developer.

```javascript
let b = null;
```

So conceptually:

| Value | Meaning |
| --- | --- |
| undefined | Default empty (JS assigned) |
| null | Intentional empty |

---

## Step 4 — Why `undefined == null` is true

This happens because of a **special rule** in JavaScript.

According to the ECMAScript specification:

> `null` and `undefined` are equal to each other — and nothing else.

So:

```javascript
undefined == null // true
null == undefined // true
```

JavaScript treats both as:

👉 “Absence of value”

But this rule applies **only in loose equality (**`==`).

---

## Step 5 — Why `undefined === null` is false

Strict equality checks:

1. Value
    
2. Type
    

Let’s compare:

| Value | Type |
| --- | --- |
| undefined | undefined |
| null | object |

Yes — this is a known JavaScript bug/legacy behavior:

```javascript
typeof null === "object" // true 
```

So:

```javascript
undefined === null // false
```

Different types → strict equality fails.

---

## Step 6 — Why `null == 0` is false

Now comes the tricky part.

Many developers think:

> `null` is empty → empty = 0 → so `null == 0` should be true.

`null` Does NOT Convert to 0 in Equality

Why?

Because the equality rule says:

> If one value is `null`, it only equals `undefined` — nothing else.

```javascript
null == undefined // true
null == 0         // false
null == false     // false
null == ""        // false
```

No numeric conversion happens here.

---

## Step 7 — But Wait… Comparisons Behave Differently

Here’s where JavaScript becomes weird

```javascript
null >= 0  // true
null > 0   // false
null <= 0  // true
```

Why?

Because comparison operators convert `null` to number.

```javascript
Number(null) // 0
```

So:

```javascript
0 >= 0 // true
0 > 0  // false
```

---

## Equality vs Comparison Difference

| Expression | Conversion | Result |
| --- | --- | --- |
| `null == 0` | No | false |
| `null >= 0` | Yes | true |
| `null > 0` | Yes | false |

---

## Best Practice

Always prefer strict equality:

```javascript
if (value === null) { }
if (value === undefined) { }
```

Avoid:

```javascript
value == null
```