Forma JS de comparar la igualdad.

"===" operador de igualdad estricta

Las reglas de comparación a===b son las siguientes:

1. Devuelve falso si a no es igual a b
2. Si a=null y b==null, igual, devuelve verdadero
3. Si a=indefinido y b=indefinido, igual, devuelve verdadero
4. Si a y b son ambos booleanos verdaderos o ambos booleanos falsos, iguales, devuelve verdadero
5. Devuelve verdadero si a y b son numéricos e iguales, entonces iguales. (=== considera que 0 es igual a -0 )
6. Si tanto a como b son Infinito, son iguales y devuelven verdadero ( Infinito no es igual a -Infinito, y NaN no es estrictamente igual a ningún número, incluido NaN )
7. Si tanto a como b son cadenas de caracteres, y 16 en la misma posición es el mismo valor de código Unicode, entonces a y b son iguales y devuelven verdadero. ( no es igual si a y b tienen diferentes longitudes, o si se ven iguales pero tienen diferentes valores Unicode )
8. Si a y b se refieren al mismo objeto (matriz, función), son iguales y devuelven falso. ( No es igual si se refieren a objetos diferentes, incluso si tienen exactamente las mismas propiedades y valores de propiedad )

"==" operador de igualdad

"==" Al comparar dos datos, si los dos tipos de datos son iguales, se compararán de acuerdo con la estricta igualdad "===". Si los dos tipos de datos que se van a comparar son diferentes, intente la conversión de tipos de acuerdo con lo siguiente Reglas antes de decidir Equivalencia:

1. Igual si un valor es nulo y el otro no está definido.
2. Si un valor es un número y el otro es una cadena, convierta la cadena en un número y compare los números convertidos.
3. Si uno es un valor booleano, convierta el valor booleano en un valor (verdadero se convierte en 1, falso se convierte en 0) y luego compare.
4. Si un valor es bigint (entero grande), convierta el otro valor en un valor numérico y compare.
5. Si un valor es un símbolo, es igual solo si el otro valor también hace referencia exactamente al mismo símbolo que el valor.
6. Si un valor es un objeto y el otro es un booleano, cambie el objeto a verdadero y compárelo.
7. Si un valor es un objeto (contiene una función) y el otro valor es un número o una cadena, el objeto intenta llamar implícitamente a su método valueOf, y si el método valueOf devuelve un tipo de datos que no es un objeto, use este valor de retorno para comparar con el otro valor, si valueOf devuelve un tipo de objeto, intente comparar el valor de retorno de su método toString con otro valor. ( Para el tipo Fecha, primero se probará toString y luego se probará valueOf )

Las reglas de conversión son las siguientes:

valor	convertir a cadena	convertir a numérico	convertir a booleano
indefinido	"indefinido"	Yaya	FALSO
nulo	"nulo"	0	FALSO
verdadero	"verdadero"	1
FALSO	"FALSO"	0
"" (cuerda vacía)		0	FALSO
"1.2" (cadena numérica no vacía)		1.2	verdadero
"abc" (cadena no numérica no vacía)		Yaya	verdadero
0	"0"		FALSO
-0	"0"		FALSO
1 (valor limitado distinto de cero)	"1"		verdadero
Infinidad	"Infinidad"		verdadero
-Infinidad	"-Infinidad"		verdadero
Yaya	"Yaya"		FALSO
{} (cualquier objeto)	Regla 7 anterior	La séptima regla anterior	verdadero
[] (matriz vacía)	“”	0	verdadero
[2] (un elemento numérico)	"2"	2	verdadero
["a"]	método de unión de llamadas	Yaya	verdadero
cualquier función	Regla 7 anterior	Yaya	verdadero

Después de leer detenidamente el siguiente código y los comentarios, ¡definitivamente ganará mucho! Por supuesto, no se tratan aquí todas las permutaciones y combinaciones de comparación de datos.

console.log(1 == "1"); // true 将字符串"1"转成数值1
console.log(2 == true); // false 将true转成1
console.log("abc" == true); // false 将true转成字符串"true"
console.log(null == undefined); // true 规则1
console.log(NaN == "abc"); // 将"abc"转成数值为NaN,但==认为NaN与NaN不相等
console.log(Infinity == "Infinity"); // 将字符串"Infinity"转成数值Infinity
console.log(0 == -0); // ==认为+0与-0相等
console.log([] == ""); // true 空数组转成空字符串
console.log([] == true); // false []转成0.true转成1
console.log([] == []); // false 两个数组不是同一个对象
console.log([] == ![]); // false 后一个空数组转成布尔值取反为false,转换后类型不一样。false再转成0，再将前一个数组转成数值0
console.log([1] == 1); // true 数组转[1]调用join方法转成字符串"1"，再将字符串"1"转成数值1
console.log([1, 2] == "1,2"); // true 数组调用join方法转成字符串"1,2"
console.log(Symbol.iterator == false); // false 规则5
console.log(Symbol.iterator == true); // false 规则5
console.log(2n == "2"); // true 把字符串"2"转成数值2，再与bigint值2n 进行值的比较
let o1 = {
  valueOf() {
    return 3;
  },
};

let o2 = {
  valueOf() {
    return {};
  },
  toString() {
    return "3";
  },
};

console.log(o1 == o2); // false 不是同一个对象
console.log(o1 == 3); // true 按照规则7将o1转换为数值3
console.log(o2 == 3); // true 按照规则7将o2转换为"3"（先调用valueOf返回不是非对象数据类型，会再调用toString）,再将"3"转换为数值3

Object.is(a,b) determina si a y b tienen el mismo valor (SameValue)

El método Object.is juzga si dos valores tienen el mismo valor.Si se cumple alguna de las siguientes condiciones, los dos valores son iguales:

• son indefinidos
• son todos nulos
• ambos  true o ambos false
• son todas cadenas de la misma longitud, con los mismos caracteres, en el mismo orden
• Ambos son el mismo objeto (lo que significa que ambos son referencias de valor al mismo objeto)
• son numeros y
  • son todos +0
  • son todos -0
  • son todos NaN
  • ambos tienen el mismo valor, distinto de cero y ninguno es NaN

Object.is() A diferencia de ==. == El operador proyecta las variables en ambos lados (si no son del mismo tipo) antes de evaluar la igualdad (este comportamiento se evaluará  "" == false como  true),  Object.is sin forzar los valores en ambos lados.

Object.is() Tampoco es lo mismo que === . La diferencia es que tratan el cero con signo y NaN de manera diferente, por ejemplo, === los operadores (y  == los operadores) tratan los números  -0 y  +0 como iguales, pero Number.NaN y NaN como desiguales.

SameValueZero (api aún no disponible)

Piensa que 0, +0, -0 son todos iguales. Otros son los mismos que SameValue.

El método include de la matriz , la comparación dentro del método has del Mapa son tales reglas.