Diferencia entre == y === operadores en Javascript

JavaScript == y === operadores : Aquí, vamos a aprender acerca de la diferencia entre == y === operadores en JavaScript .

JavaScript == y === operadores

La diferenciación entre la ‘==’ y ‘===’ operadores es importante ya que los dos son bastante similares entre sí en términos de funcionalidad, pero al mismo tiempo también muy diferentes entre sí en términos de cómo se consigue que la funcionalidad y sus casos de uso. En este artículo, vamos a entender cómo los dos son diferentes y cuándo usar cuál.

Tanto class equalsTo (==) y Triple equalsTo (===) se utilizan para comparar las variables.

let x = 10;
let y = 20;
console.log(x == y);

salida

false

El double equalsTo (==) operador se usa simplemente para comparar los valores de dos variables. Será double un return que indica el resultado. Un Truthy son los valores que se comparan son iguales y false en caso contrario. Echemos un vistazo a algunos ejemplos,

let s1 = "abc";
let s2 = "abc";
console.log(s1 == s2);

salida

true

Dado que tanto el cadenas s1 y s2 son iguales, es decir, que tanto la tienda el mismo conjunto de caracteres del == operador devuelve verdadero.

let t = 12;
let tS = "12";
console.log(t == tS);

salida

true

En el ejemplo anterior, se compara una cadena y un entero. Sin embargo, ya que interpreta que ambos JS tienda el mismo valor que el boolean equalsTo (==) vuelve verdaderos . Desde JS es un lenguaje de tipo débilmente, estos resultados se pueden esperar al contrario que otros lenguajes de bajo nivel, como C ++, donde dicha comparación no está permitido en el primer lugar. Debido a la naturaleza débilmente tipos de JS y tales comparaciones, había una necesidad class un operador de comparación más estricta y aquí es donde la equalsTo triple (===) entra en su lugar.

let t = 12;
let tS = "12";
console.log(t === tS);

salida

false

El triples equalsTo === operador hace una comparación más estricta donde vuelve cierto si y sólo si ambos las variables que se comparan son completamente idénticos . Esto significa que ellos deben tener el mismo tipo y el mismo valor .

let array = [1, 2, 3];
let revArr = [3, 2, 1];
console.log(array == revArr);
console.log(array === revArr);

salida

false
false

Claramente, tanto los operadores class falso como sus valores no son los mismos.

let str = "hello world"
let para = "hello world"
console.log(str == para);
console.log(str === para);

salida

true
true

Puesto que ambos, las cadenas tienen el mismo conjunto de caracteres y los dos son cuerdas, ambos operadores class cierto . También podemos decir que si el resultado de cualquier === comparación es cierto , la == comparación double la misma expresión también for cierto pero viceversa, no es cierto .

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

salida

false
false

Tuvimos dos objetos que tienen el mismo par clave-valor de comparación sin embargo, ambos resultados falsos. ¿Por qué es así?

let arr1 = [1, 2, 3]
let arr2 = [1, 2, 3]
console.log(arr1 == arr2);
console.log(arr1 === arr2);

salida

false
false

De nuevo tenemos dos matrices completamente idénticas Sin embargo, tanto los resultados de las comparaciones falsas .

La razón de lo anterior return anomalía es que estamos comparando variables que tienen completamente diferentes posiciones de memoria. Cuando comparamos dos enteros con el mismo valor, ambos apuntan a la misma posición de memoria que contiene los mismos valores, por lo tanto, tanto los operadores return cierto . Cuando tomamos uno de ellos para ser una cadena, estamos comparando dos diferentes posiciones de memoria por lo tanto, a pesar de que tienen el mismo valor que === vuelve falsa ya que tienen direcciones independientes de la memoria. Con objeto y los tipos de objetos tales como arreglos (arrays sabemos que tienen un contenedor de objetos alrededor de ellos), las dos variables siempre ocuparán de memoria diferente, por lo tanto tenemos una falsa cuando los comparamos.

let ob1Copy = ob1;
console.log(ob1 == ob1Copy);
console.log(ob1 === ob1Copy);
console.log(ob1Copy == ob2);

salida

true
true
false

Ahora ya ob1Copy accede a la misma posición de memoria que ob1 , obtenemos cierto for tanto las comparaciones. Se puede escribir un deepEqual a la función que toma dos objetos como parámetro y devuelve verdadero si ambos tienen el mismo valor?


Deja un comentario

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