igualdad en javascript

Question

Al trabajar con javascript, ¿alguien puede proporcionarme una buena referencia o explicación sobre las pruebas de igualdad/desigualdad y escribir coerción?

De lo que he estado leyendo veo dónde hay dos principios de pensamiento sobre el uso de eqeq (==) vs. eqeqeq (===) algunos sienten que no se debe usar eqeq y siempre se usa eqeqeq como es más seguro de usar

He estado jugando con algunas muestras básicas y estoy teniendo problemas para discernir la diferencia o cuándo es mejor utilizar una sobre la otra:

Por ejemplo: he aquí algo de guión básico que estaba escribiendo a cabo. Cuando pruebo usando eqeq o eqeqeq obtengo el mismo resultado. Todavía no he visto un ejemplo en el que obtuviera resultados diferentes (es decir, usar eqeq devuelve verdadero donde eqeqeq devuelve falso).

function write(message){ 

    document.getElementById('message').innerHTML += message +'<br/>'; 
} 


var tim = { name: "tim" }; 
var tim2 = { name: "tim" }; 
//objects are equal to themselves (== vs ==== eqeq or eqeqeq) 
write("tim eq tim: " + (tim == tim)); //returns true 

//objects are only equal to themselves regardless of containing value got that 
write("tim eq tim2: " + (tim === tim2)); //returns false 

//access the primative type to test true or false 
write("tim value eq tim2 value: " + (tim.name === tim2.name)); //returns true 
//how does this differ in efficency over the eqeq operator? is one safer to use over the other? 
//write("tim value eq tim2 value: " + (tim.name == tim2.name)); //also returns true 

//testing primatives 

write("apple eqeqeq apple: " + ("apple" === "apple")); //true 
write("apple eqeqeq apple: " + ("apple" == "apple")); //true 

¿Alguien me puede dar una explicación o referencia que pueda leer que ayude a aclarar esto un poco más?

aplausos,

Answer 1

La diferencia entre == y === es bastante simple: == es una comparación del valor. === es una comparación de valor y tipo. Usar === evitará que JavaScript determine dinámicamente el tipo y compara los valores exactamente como son.

5 == "5"  //true - JS compares the number 5 to a string of "5" and determines the contents are the same 
5 === "5" //false - A character is not a number, they can't be the same. 

0 == false //true - false is a bool, 0 is numerical, but JS determines that 0 evaluates to false 
0 === false //false - numeric is not boolean, they can't be exactly the same thing 

5 == 5.0  //true - need I say more? 
5 === 5.0 //true - one is a float and one is an int, but JS treats them all as numerical 

Me parece fundamental para las pruebas con funciones que pueden devolver tanto falso (para el fracaso) como 0 (como resultado legítimo).

JS tiene un total de 5 tipos primitivos = numéricos, de cadena, booleanos, nulos e indefinidos. === requiere que ambos argumentos sean del mismo tipo y valor igual para devolver verdadero. No hay float, int, long, short, etc. - cualquier tipo de número se agrupa como numérico.

Answer 2

=== es el operador de igualdad estricta que devuelve verdadero solo si las variables tienen el mismo tipo y valor.

a = 1; 
b = "1"; 

a == b devolverá true, a === b volverá falsa

Answer 3

La regla de == no es fácil de recordar, se puede obtener toda la respuesta correcta de ejemplos a continuación?

"" == "0" // false 
0 == "" // true 
0 == "0" // true 
false == "false" // false 
false == "0" // true 
false == undefined // false 
false == null // false 
null == undefined // true 
" \t\r\n" == 0 // true 

lo que es mejor usar solamente ===, y nunca utilizar ==.

Answer 4

Es simple.
== realiza una conversión de tipo y luego compara los valores convertidos al valor deseado
=== no realiza la conversión de tipo y compara directamente sus valores.
Obviamente, === es mejor en términos de rendimiento y precisión, pero == también es conveniente en algunos casos para que pueda usar ambos si se ajustan a sus necesidades.

comparisons

Saludos!

Answer 5

Debes haber escuchado a alguien que javascript es un lenguaje muy poco tipeado.

Así como se ha dicho anteriormente surrealista El operador (==) se utiliza cuando sólo se desea comparar los valores de los argumentos y no se preocupan por su tipo de como 5 == "5" devolverá true. Este es el caso cuando desea ver (por ejemplo, qué tecla presionó el usuario y no le importa si el tipo de letra puede ser una cadena, un carácter o un número entero).

Pero hay un caso en el que el tipo de argumentos también importa. En tales casos, quiere comparar los tipos de operadores. Entonces, en esos casos, usa el operador de igualdad triple. Por ejemplo, si está realizando algunas operaciones de adición o multiplicación, quiere asegurarse de que los operandos sean del tipo compatible. Entonces usas el operador triple (===).

Answer 6

A continuación se muestra una lista muy completa de las cosas que no vas a esperar al usar operadores de igualdad

Todos los siguientes son verdaderas:

0    ==   "" 
0    ==   " " 
0    ==   [] 
false   ==   "" 
false   ==   " " 
false   ==   [] 
[]    ==   "" 
null   ==   undefined 
"str"   ==   ["str"] 

"1"    ==   true 
"0"    ==   false 

"null"   !=   null 
"false"   !=   false 
"true"   !=   true 
"undefined"  !=   undefined 
"NaN"   !=   NaN 

NaN    !=   NaN   //exception: NO exception 
{}    !=   {}   //exception: same reference 
[]    !=   []   //exception: same reference 

-------------------------------------- 

new Number(10)  !==   10 
new String("str") !==   "str" 
NaN     !==   NaN  //exception: NO exception 
{}     !==   {}  //exception: same reference 
[]     !==   []  //exception: same reference 

_{(Algunos de ellos han venido de this source)}

En conclusión, nunca use ==. Ni siquiera cuando se desea:.

"Se recomienda utilizar sólo el operador de igualdad estricta En casos en que los tipos deben ser coaccionado, se debe hacer de forma explícita y no deja de complicarse la coacción de la lengua reglas."

_(source)