Diferencia entre! = O! == operador en JavaScript

Aquí, vamos a explorar la diferencia entre ! = Y! == operadores que a menudo se conciben erróneamente por el novato programadores de JavaScript. Casi todo el tiempo que se le pide en las entrevistas de JavaScript.

Podemos percibir las diferencias entre estos dos operadores como la misma diferencia que se produce entre class equalsTo (==) y (===) los operadores de triple equalsTo. Ya sabemos que el (!) no-operador se utiliza junto con (=) operador se utiliza para comprobar double desigualdades.

let a = 10;
let b = 20;
console.log(a != b);

salida

true

Dado que tanto un y b diferentes valores de retención, obtenemos una Truthy regresar de la desigualdad.

let c = 50;
let d = 50;
console.log(c!=d);

salida

false

Y, por supuesto, en la anterior for ya que ambos tienen los mismos valores ! = Operador devuelve falso . Por lo tanto podemos decir que el ! = Operador comprueba si las dos variables que se comparan tienen el mismo valor o mantenga el mismo valor. Si no lo hacen, devuelve verdadero y falso en caso contrario, como hemos visto en las anteriores dos ejemplos.

let s = 101011;
let name = "sam";
console.log(s != name);
console.log(s !== name);

salida

true
true

Hemos comparado dos variables que son completamente diferentes tipos almacenar los mismos valores y obtenemos Truthy class tanto las expresiones de comparación. Ahora, vean el siguiente ejemplo:

let a1 = 10;
let a2 = "10";
console.log(a1 !== a2);
console.log(a1 != a2);

salida

true
false

En la comparación anterior, estamos comparando dos mismos valores, debido a que los operador = nos devuelve falsas pero nos’ volver a la comparación de dos tipos diferentes debido a lo cual los ! == operador vuelve verdaderos . Por lo tanto, podemos decir que el operador ! == no sólo comprueba class los valores sino también case del tipo de las variables que se comparan. Dado que en este for tanto las variables tenían diferentes tipos, que fueron evaluados como desigual por el operador ! == y por lo tanto nos dieron el resultado verdadero.

let ob1 = { name: "Mario" }
let ob2 = { name: "Mario" }
console.log(a!=b);
console.log(a!==b);

salida

true
true

Nuestros dos objetos son completamente idénticos sin embargo, los ! = así como la ! == operador vuelve cierto lo que indica que ambos son desiguales. ¿Por qué es así? Esto tiene algo que ver con el direccionamiento de memoria de variables. Tanto los objetos ocupan completamente diferentes bloques de memoria y por lo tanto se consideran como dos casos separados o dos entidades separadas.

let ob3 = ob1;
console.log(ob1 != ob3);
console.log(ob1 !== ob3);

salida

false
false

Desde ahora OB3 ocupa la misma dirección que ob1 , que son considerados completamente idénticos. Se puede concluir que fuera de la ! = y ! == hace una comparación más estricta que la otra?


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *