Comprobar la igualdad de cadenas en JavaScript

1. Cuándo usar un operador para la igualdad de cadenas en JavaScript
2. Comprender la igualdad de cadenas en JavaScript con ejemplos

En JavaScript, hay cuatro operadores que puede usar para verificar la igualdad de cadenas. Estos operadores se denominan operadores de comparación.

1. Estricto igual (===): El Estricto igual (también conocido como operador triple igual) comprueba el valor de la variable y su tipo de datos. Si ambas cosas son iguales, solo devuelve true, de lo contrario, devuelve false.
2. Estricto no igual (!==): Esto es lo opuesto a Estricto igual. Si el valor o el tipo de datos no coincide, devuelve true; de lo contrario, false.
3. Igual (==): El doble signo igual comprueba solo el valor de una variable. Si el valor coincide, devuelve true, de lo contrario, devuelve false. No le importa el tipo de variable.
4. No igual (!=): Esto es lo opuesto a Igual (==). Devuelve true solo si los valores dentro de las variables no coinciden, independientemente de su tipo de datos. Si los valores coinciden entre sí, devuelve false.

Estos operadores se utilizan no solo para verificar la igualdad de cadenas, sino también para verificar la igualdad de otros tipos de datos. De estos cuatro operadores, averigüemos cuál es el mejor para verificar la igualdad de cadenas según los casos de uso.

Es posible que ya haya visto el tercer y cuarto operador, es decir, == y !=, Que también son bastante comunes en otros lenguajes de programación. Pero la forma en que funciona en JavaScript es un poco diferente a otros lenguajes.

Cuándo usar un operador para la igualdad de cadenas en JavaScript

En relación con JavaScript, a continuación se muestran algunos casos de uso en los que puede utilizar cualquiera de los operadores === o ==.

• Si un valor en comparación puede ser un valor true o false, utilice === y no ==.
• Si un valor en comparación podría ser cualquiera de estos valores específicos (0, "" o [] - matriz vacía), use === en lugar de ==.
• En cualquier otro caso, es seguro utilizar ==. No solo es seguro, sino que también simplifica su código y mejora la legibilidad.

Las mismas reglas anteriores son aplicables al usar los operadores Estricto no igual (!==) y No igual (!=). Para obtener más información sobre las reglas específicas, puede leer la sección 11.9.3 de la especificación ES5.

Comprender la igualdad de cadenas en JavaScript con ejemplos

Tomemos algunos de los ejemplos y comprendamos estas cosas en detalle.

En este ejemplo, hemos tomado dos variables, name_1 y name_2. Ambos toman "adam" como valor de cadena. Ahora apliquemos cada uno de los operadores anteriores y veamos el resultado que obtenemos.

Aquí, hemos utilizado cuatro declaraciones if y else, cada una de las cuales representa diferentes operadores de comparación. Dado que tanto el valor como el tipo de datos son los mismos para las variables name_1 y name_2, el operador triple igual o estricto igual (===) imprimirá True como salida. Y el doble igual == también imprimirá True, ya que ambas variables tienen los mismos valores.

let name_1 = 'adam';
let name_2 = 'adam';

// Strict Equal
if (name_1 === name_2)
  console.log('True');
else
  console.log('False');

// Equal
if (name_1 == name_2)
  console.log('True');
else
  console.log('False');

// Strict not equal
if (name_1 !== name_2)
  console.log('True');
else
  console.log('False');

// Not equal
if (name_1 != name_2)
  console.log('True');
else
  console.log('False');

Producción :

True
True
False
False

Cuando se utiliza el operador Estricto no igual (!==) y el operador no igual (!=), Ambos imprimirán False como salida ya que el valor en sí es el mismo en ambas variables.

A continuación se muestra otro ejemplo en el que compararemos una cadena con un número entero. Aquí, tenemos una variable str con un valor de "80", un valor de cadena. Tenemos otra variable, num, que contiene un valor entero de "80". Dado que ambas variables tienen los mismos valores con diferentes tipos de datos, veamos qué sucede cuando se utilizan los distintos operadores de comparación en ellas.

let str = '80';
let num = 80;

// Strict Equal
if (str === num)
  console.log('True');
else
  console.log('False')

  // Equal
  if (str == num) console.log('True');
else console.log('False')

// Strict not equal
if (str !== num) console.log('True');
else console.log('False')

// Not equal
if (str != num) console.log('True');
else console.log('False')

Producción :

False
True
True
False

Como en el primer ejemplo, también tenemos cuatro declaraciones if y else, cada una de las cuales representa diferentes operadores de comparación.

Cuando usamos Estricto igual o triple igual (===), obtenemos False como resultado. La razón es que el tipo de datos es diferente aunque los valores sean los mismos. Pero cuando usamos el doble igual (==), obtenemos True como la salida porque el doble igual sólo verifica el valor y no el tipo.

Y cuando utilizamos Estricto no igual (!==), obtenemos True como salida porque el valor de cadena "80" no es igual al valor entero 80; por lo tanto, devuelve True.

Por último, el operador no igual (!=) Solo compara el valor de las dos variables. Los valores deben ser diferentes para imprimir True. Dado que los valores son los mismos en este caso, devuelve False.