# Por qué `NaN` no es igual a `NaN` y otras rarezas de JavaScript 🚩

En el mundo de la programación, JavaScript está lleno de sorpresas y peculiaridades que pueden confundir incluso a los desarrolladores más experimentados. Una de esas rarezas es el comportamiento del identificador `NaN`. ¿Alguna vez te has preguntado por qué `NaN` no es igual a `NaN`? Aquí te lo explicamos.

## ¿Qué es `NaN`?

`NaN` significa "Not-a-Number" (no es un número) y es un valor especial en JavaScript que representa un resultado de operación numérica indefinida o fallida. Algunas operaciones que producen `NaN` son dividir un número por cero o convertir una cadena no numérica en un número.

```javascript
console.log(0 / 0); // NaN
console.log(parseInt('hello')); // NaN
```

## ¿Por qué `NaN` no es igual a `NaN`?

En JavaScript, `NaN` es el único valor que no es igual a sí mismo. Esta es una propiedad definida por el estándar IEEE 754 para aritmética de punto flotante. La lógica detrás de esto es que `NaN` es un resultado indeterminado, por lo tanto, cualquier comparación entre dos valores `NaN` también debe ser indeterminada.

```javascript
console.log(NaN == NaN); // false
console.log(NaN === NaN); // false
```

Para verificar si un valor es `NaN`, JavaScript proporciona la función `isNaN()`:

```javascript
console.log(isNaN(NaN)); // true
```

## Otras rarezas de JavaScript

### 1. Coerción de tipos
Una de las características más desconcertantes de JavaScript es su coerción de tipos automática. Por ejemplo:

```javascript
console.log('5' + 3); // "53"
console.log('5' - 3); // 2
```

### 2. Comparaciones curiosas
El comportamiento de las comparaciones en JavaScript puede ser sorprendente:

```javascript
console.log(0 == false); // true
console.log(0 === false); // false
console.log(null == undefined); // true
console.log(null === undefined); // false
```

### 3. Variables hoisting
En JavaScript, las declaraciones de variables son "hoisted" al inicio de su contexto de ejecución:

```javascript
console.log(myVar); // undefined
var myVar = 5;
```

Esto es porque la declaración `var myVar;` se mueve al inicio de su función o contexto global, pero su asignación `= 5` no.

## Conclusiones

JavaScript es un lenguaje poderoso pero a veces ilógico para los que no lo conocen en profundidad. Entender estas rarezas no solo te ayudará a evitar errores sino también a escribir un código más limpio y eficiente.

Si este artículo te aclaró alguna duda o te hizo reír con estas peculiaridades, ¡compártelo con otros desarrolladores curiosos y sigue explorando el fascinante mundo de JavaScript!