Comparaciones de igualdad

En JavaScript, existen diferentes algoritmos para comparar valores, y cada uno de ellos se comporta de manera diferente. Hablaremos del funcionamiento de los más importantes.

Igualdad abstracta

La igualdad abstracta o igualdad débil es un algoritmo de comparación que convierte los valores a un tipo común antes de compararlos. Esta comparación se realiza con el operador ==.

Por este motivo es de suma importancia tener en cuenta una serie de reglas para evitar errores en la comparación de valores.

Reglas de comparación

	Operando B
		Undefined	Null	Number	String	Boolean	Object
Operando A	Undefined	`true`	`true`	`false`	`false`	`false`	`false`
	Null	`true`	`true`	`false`	`false`	`false`	`false`
	Number	`false`	`false`	`A === B`	`A === ToNumber(B)`	`A === ToNumber(B)`	`A == ToPrimitive(B)`
	String	`false`	`false`	`ToNumber(A) === B`	`A === B`	`ToNumber(A) === ToNumber(B)`	`A == ToPrimitive(B)`
	Boolean	`false`	`false`	`ToNumber(A) === B`	`ToNumber(A) === ToNumber(B)`	`A === B`	`ToNumber(A) == ToPrimitive(B)`
	Object	`false`	`false`	`ToPrimitive(A) == B`	`ToPrimitive(A) == B`	`ToPrimitive(A) == ToNumber(B)`	`A === B`

Mediante la tabla anterior podemos establecer las siguientes afirmaciones.

La comparación entre null y undefined siempre resulta en true.

Para cualquier otro tipo de dato, veremos que el tipo de dato predilecto como resultado de la conversión es Number. Esto se realiza mediante la función ToNumber.

1
console.log(1 == '1'); // true
2
console.log(1 == true); // true
3

4
console.log(0 == false); // true
5
console.log(0 == ''); // true
6

7
console.log('' == false); // true
8
console.log('' == 0); // true
9

10
console.log(null == undefined); // true

Sólo los objetos son comparados mediante ToPrimitive, el cual convierte el objeto a un valor primitivo. Para esto se utilizan los métodos valueOf y toString, siempre que sean accesibles.

Los arrays son objetos, por lo que también se comparan mediante ToPrimitive. En la mayoría de los casos, veremos que estos son convertidos a cadenas de texto, lo cual permite compararlos con otros valores de tipo String. En última instancia, la cadena de texto resultante puede ser convertida a un número, permitiendo compararlos con valores de tipo Number.

1
console.log([1, 2] == '1,2'); // true
2
console.log([1, 2] == '1'); // false
3

4
console.log([] == ''); // true
5
console.log([] == 0); // true

Igualdad estricta

El operador de igualdad estricta o identidad compara los valores sin realizar conversiones de tipo. Esta comparación se realiza con el operador ===.

Entonces, si los valores tienen tipos diferentes, la comparación resultará en false.

1
console.log(1 === '1'); // false
2
console.log(1 === true); // false
3

4
console.log(0 === false); // false
5
console.log(0 === ''); // false
6

7
console.log(null === undefined); // false

Particularmente, si ambos valores son objetos, la comparación se realizará por referencia, es decir, si ambos objetos apuntan a la misma dirección de memoria.

1
const obj1 = {};
2
const obj2 = {};
3

4
console.log(obj1 === obj2); // false
5

6
const obj3 = obj1;
7

8
console.log(obj1 === obj3); // true

Bibliografía

MDN Web Docs - Equality comparisons and sameness.