En JavaScript, los operadores == y == pueden usarse para determinar si los dos valores son iguales; La diferencia es que si los dos valores que se juzgan son inconsistentes, el operador === devolverá directamente falso, mientras que el operador == emitirá un juicio después de la conversión de tipo. Las reglas de juicio detalladas son las siguientes:
=== Reglas para juzgar a los operadores
1. Si los tipos de los dos valores son inconsistentes, devuelva falso.
2. Si los dos valores tienen el mismo tipo y los valores son los mismos, regrese verdadero. Nan es un caso especial, nan === nan devuelve falso.
3. Si ambos valores son de tipo de objeto, entonces como Java, a menos que las referencias sean consistentes (los puntos de referencia a la misma dirección de objeto), incluso si el contenido en el objeto es exactamente el mismo, los dos valores se consideran inconsistentes, y la operación correspondiente devolverá falso. Por ejemplo, cree dos matrices nuevas con exactamente el mismo contenido, y luego realice la operación === en ellas y devuelva el resultado a False, aunque su contenido es exactamente el mismo, todavía pertenecen a dos objetos diferentes.
4.0 ===-0 Devuelve verdadero.
== Reglas para el juicio de los operadores
El operador == escribirá el valor y luego lo comparará. La conversión de tipo sigue los siguientes principios: primero conviértalo en el número y luego compárelo, y primero conviértelo en cadena y luego compárelo. Las reglas de juicio específicas son las siguientes:
1. Si los dos tipos de valor son los mismos, regrese después de realizar la operación ===.
2.Null == Undefined es verdadero.
3. Verdadero se convertirá a 1 y se comparará, False se convertirá a 0 y se comparará.
4. Si uno de los valores es un objeto, conviértalo en número y luego compárelo, excepto por el objeto Fecha.
5. Si uno de los valores es un objeto de fecha, conviértelo en cadena y luego compare.
experimento
La copia del código es la siguiente:
console.log ("3" === 3); // falso
console.log (nan === nan); // falso
var a = {x: 1, y: 2};
var b = {x: 1, y: 2};
var c = a;
console.log (a === b); // falso
console.log (a === c); // Verdadero
console.log (0 === -0); // Verdadero
console.log ("3" == 3); // Verdadero
console.log (nulo == Undefined); // Verdadero
console.log (true == 1); // true
console.log (true == 9); // falso
console.log ([9] == 9); // Verdadero
console.log ([9] == "9"); // Verdadero
var d = nueva fecha ();
var s = d.ToString ();
var n = d.valueOf ();
console.log (d == s); // Verdadero
console.log (d == n); // falso