¿Cuál es la forma correcta de verificar la igualdad de cadenas en JavaScript?

¿Cuál es la forma correcta de verificar la igualdad entre cadenas en JavaScript?

siempre Hasta que comprenda completamente las diferencias e implicaciones del uso de losoperadores==y===, use el===operador ya que lo salvará de errores oscuros (no obvios) y WTF. El==operador"regular"puede tener resultados muy inesperados debido a la coerción de tipo internamente, por lo que usar===siempre es el enfoque recomendado.

Para obtener información sobre esto y otras partes "buenas contra malas" de Javascript, lea sobre el Sr. Douglas Crockford y su trabajo. Hay una gran charla técnica de Google donde resume mucha buena información: http://www.youtube.com/watch?v=hQVTIJBZook

Actualizar:

La serie You Don't Know JS de Kyle Simpson es excelente (y gratuita para leer en línea). La serie aborda las áreas comúnmente incomprendidas del lenguaje y explica las "partes malas" que Crockford sugiere que evite. Al comprenderlos, puede hacer un uso adecuado de ellos y evitar las trampas.

El libro " Up & Going " incluye una sección sobre Igualdad , con este resumen específico de cuándo usar los operadores flojos ( ==) versus estrictos ( ===):

Para resumir una gran cantidad de detalles en algunas conclusiones simples y ayudarlo a saber si usarlo ==o ===en varias situaciones, estas son mis reglas simples:

• Si cualquiera de los valores (también conocido como lado) en una comparación podría ser el valor trueo false, evítelo ==y úselo ===.
• Si cualquiera de los valores en una comparación podría ser de estos valores específicos ( 0, ""o []- matriz vacía), evitar el ==y uso ===.
• En todos los demás casos, es seguro de usar ==. No solo es seguro, sino que en muchos casos simplifica su código de una manera que mejora la legibilidad.

Todavía recomiendo la charla de Crockford para desarrolladores que no quieren invertir el tiempo para comprender realmente Javascript; es un buen consejo para un desarrollador que solo ocasionalmente trabaja en Javascript.

Si sabe que son cadenas, no hay necesidad de verificar el tipo.

"a" == "b"

Sin embargo, tenga en cuenta que los objetos de cadena no serán iguales.

new String("a") == new String("a")

devolverá falso.

Llame al método valueOf () para convertirlo en una primitiva para objetos String,

new String("a").valueOf() == new String("a").valueOf()

volverá verdadero

Solo una adición a las respuestas: si todos estos métodos devuelven falso, incluso si las cadenas parecen ser iguales, es posible que haya un espacio en blanco a la izquierda o derecha de una cadena. Entonces, solo ponga un .trim()al final de las cadenas antes de comparar:

if(s1.trim() === s2.trim())
{
    // your code
}

He perdido horas tratando de descubrir qué está mal. Espero que esto ayude a alguien!

lo que me llevó a esta pregunta es la paddingywhite-spaces

mira mi caso

 if (title === "LastName")
      doSomething();

y el título era " LastName"

entonces quizás tengas que usar trimfunciones como esta

var title = $(this).text().trim();

A menos que realmente sepa cómo funciona la coerción, debe evitar ==y utilizar el operador de identidad en su ===lugar. Pero deberías leer esto para entender cómo funciona .

Si lo usa ==, deja que el idioma haga algún tipo de coerción por usted, por ejemplo:

"1" == 1 // true
"0" == false // true
[] == false // true

Como Douglas Crockford dijo en su libro:

Siempre es mejor usar el operador de identidad.

En realidad, hay dos formas en que las cadenas se pueden hacer en JavaScript.

1. var str = 'Javascript'; Esto crea un valor de cadena primitivo.

2. var obj = new String('Javascript');Esto crea un objeto contenedor de tipo String.

   typeof str // string
typeof obj // object

Entonces, la mejor manera de verificar la igualdad es usar el ===operador porque verifica el valor y el tipo de ambos operandos.

Si desea verificar la igualdad entre dos objetos, entonces usar String.prototype.valueOfes la forma correcta.

new String('javascript').valueOf() == new String('javascript').valueOf()

La cadena Objectsse puede verificar con un JSON.stringyfy()truco.

var me = new String("me");
var you = new String("me");
var isEquel = JSON.stringify(me) === JSON.stringify(you);
console.log(isEquel);

Teniendo en cuenta que ambas cadenas pueden ser muy grandes, hay 2 enfoques principales bitwise searchylocaleCompare

Recomiendo esta función

function compareLargeStrings(a,b){
    if (a.length !== b.length) {
         return false;
    }
    return a.localeCompare(b) === 0;
}

La forma más fácil de hacerlo es usar un operador ternario como este:

 "was" == "was" ? true : false

pero si la cadena que desea comparar está en una matriz, usará el filtro es6

let stringArray  = ["men", "boys", "girls", "sit", "can", "gotten"]
stringArray.filter(I=> I === boys ? 
stringArray.pop(indexOf(I)) : null)

lo anterior verificará su stringArray y cualquier cadena que coincida con la matriz que en nuestro caso elegimos "boys"

Se me ocurrió una solución alternativa durante las pruebas. puede usar la función en el prototipo de cadena.

String.prototype.betwenStr = function(one){

return JSON.stringify(new String(this)) === JSON.stringify(new String(one));

}


 //call it
 "hello world".betweenStr("hello world"); //returns boolean 
 //value

funciona bien en navegadores cromados