# Comparar valores en Javascript

Una de las acciones mas frecuentes que realizamos cuando estamos desarrollando alguna funcionalidad o programa en cualquier lenguaje es comprar valores de variables.

En este artículo veremos un poco de como funciona la comparación de valores en JS. Es una de las características que en ocaciones pude no resultar como nuestra intuición nos dice.

Para entender de una forma más sencilla como comparar valores en JS es importante que tengamos claro nuestro mapa mental de como funciona JS.

## Formas de comparar valores

En el universo de JS tenemos 3 formas de comprar valores.

* **Comparación estricta :** `a === b`
    
* **Comparación no estricta:**`a == b`
    
* **Comparación del mismo valor:** `Object.is(a, b)`
    

Vamos a comenzar por el último tipo de comparación. Es poco común encontrar información detallada de como funciona este tipo de comparación. No te vayas seguro aprenderás cosas interesantes.

### Comparación del mismo valor : [`Object.is`](http://Object.is)`(a, b)`

En JS esta sintaxis nos dice **si el valor de a es igual al valor de b**

```javascript
const a = 2
const b = 2
const c = {}
const d = {}
console.log(Object.is(a, b)); // true
console.log(Object.is(c, d)); // false
```

> A pesar que el nombre comienza con OBJECT, esta funcionalidad no está restringida a comprar objetos, se puede comparar cualquier tipo de valores.

**¿Que significa que el valor sea IGUAL al otro valor?**

Probablemente tengas una respuesta automática a esto en tu mapa mental.

Veremos cual es tu entendimiento de **IGUALDAD**.

```javascript
let enanosBlancaNieves = 7;
let continentes = '7';
let maravillasMundiales = 3 + 4;
```

Ahora comparemos esos valores. No hagas trampa, puedes escribir en una hoja cual es tu proceso de pensamiento para llegar al resultado.

```javascript
console.log(Object.is(enanosBlancaNieves, continentes)); // ?
console.log(Object.is(continentes, maravillasMundiales)); // ?
console.log(Object.is(maravillasMundiales, enanosBlancaNieves)); // ?
```

Ya tienes tu respuesta? Seguro?

* **Object.is(enanosBlancaNieves, continentes) es FALSO** porque cada elemento apunta a un valor diferente, **‘7‘ vive en un lugar diferente a 7.**
    
* **Object.is(continentes, maravillasMundiales) es FALSO** porque cada elemento apunta a un valor diferente. **‘7‘ vive en un lugar diferente a 7.**
    
* **Object.is(maravillasMundiales, enanosBlancaNieves) es VERDADERO** porque cada elemento apunta a un mismo valor. **7 vive en un el mismo lugar que 7.**
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729356646616/4610219b-1bbd-4a83-92ad-83190c42dfa4.jpeg align="center")

Perdón por mis diagramas. En realidad **maravillasMundiales** y **enanosBlancaNieves** tienen el mismo valor 7, apuntan al mismo valor. En el universo de JS **solo existe un 7,** todas las variables que se les asigne el 7 , realmente están obteniendo **una referencia a ese 7** por lo que todas serían iguales.

## Que pasa con los objetos.

Bueno los objetos **no se puede comparar de forma estricta** (===) ni con Object.is, si puedes claro nada te lo impide pero el resultado no será el esperado. Esto porque cada vez que defines **const b = {}** estas creando un nuevo objeto en el universo de Javascript. Por lo tanto :

```javascript
const a = {}
const b = {}
console.log(a === b ) // false
console.log(Object.is(a,b)) // false
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729356773994/682bd1dc-d7c7-44ad-a189-96094f4d50e3.jpeg align="center")

## Comparación estricta

La comparación estricta **\===** es casi casi igual que la comparación de **Object.is** solo hay unos casos donde no se comporta de igual manera.

```javascript
const a = 2
const b = 2
const c ='2'
console.log(a === b) // true
console.log( a === c) // false
```

## Casos especiales de comparación estricta

1. `NaN === NaN` es **falso**, aún cuando son el **mismo valor**.
    
2. `-0 === 0` y `0 === -0` son **verdadero**, aún cuando son **diferentes valores**.
    

Pocas veces usaremos o veremos estos casos en nuestro código. Yo personalmente solo he visto el primer caso contadas veces, el segundo **NUNCA**.

Hay toda una explicación histórica de porque esto pasa y no es objetivo de este artículo explicarlo. Una simple búsqueda en internet te puede dar todas las respuestas a esto.

Si estás desarrollando una funcionalidad donde necesitas comprobar **NaN es igual a NaN** aquí te dejo varias opciones.

```javascript
Number.isNaN(3)
Object.is(tuVaribale, NaN)
```

Listo hasta aquí este laaargo artículo, espero les ayude a entender un poco más Javacript .

Nos vemos en la próxima aventura.