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

Question

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

Answer 1

siempre Hasta que no entiende completamente las diferencias y las implicaciones del uso de los == y === operadores, utilice el operador === ya que le ahorrará de errores extraños (no es evidente) y WTFs. El operador "normal" == puede tener resultados inesperados debido a la coerción de tipo internamente, por lo que siempre se recomienda utilizar ===.

Para obtener información sobre esto, y otras partes "buenas o malas" de Javascript, lea sobre el Sr. Douglas Crockford y su trabajo. Hay una gran Google Tech Talk en el que resume un montón de buena información: http://www.youtube.com/watch?v=hQVTIJBZook

---

Actualización:

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

El "Up & Going" libro incluye una sección sobre Equality, con este resumen específica de cuándo utilizar la suelta (==) vs estrictas (===) los operadores:

a hervir bajar una gran cantidad de datos a unos simples robos de balón, y le ayudan a saber si se debe utilizar o ===== en diversas situaciones, aquí están mis reglas simples:

• Si cualquiera de los valores (también conocido como lateral) en una comparación podría ser el true o false valor, evite == y use ===.
• Si cualquiera de los valores en una comparación podría ser de estos valores específicos (0, "", o [] - matriz vacía), evitar == y utilizar ===.
• En todos otros casos, puede usar ==. No solo es seguro, sino que en muchos casos simplifica su código de una manera que mejora la legibilidad.

todavía recomiendan la charla de Crockford para los desarrolladores que no quieren invertir el tiempo para entender realmente Javascript — es un buen consejo para un desarrollador que sólo ocasionalmente trabaja en Javascript.

Answer 2

Si sabe que son cadenas, no es necesario comprobar 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 de objetos String,

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

devolverá true

Answer 3

realidad, hay dos formas en las 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 del tipo String.

   typeof str // string
typeof obj // object

Así que la mejor manera de comprobar la igualdad está utilizando el operador === porque comprueba valor, así como el tipo de los dos operandos.

Si desea comprobar la igualdad entre dos objetos, utilice String.prototype.valueOf de la manera correcta.

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

Answer 4

A menos que realmente sabe cómo funciona la coerción, se debe evitar == y utilizar el operador identidad === lugar. Pero debería read this to understand how it works.

Si utiliza ==, deja que el lenguaje de hacer algún tipo de coacción para usted, así que por ejemplo:

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

Como Douglas Crockford dice en su libro:

Siempre utilice mejor la operador de identidad.

Answer 5

lo que me llevó a esta pregunta es el padding y white-spaces

revisar mi caso

if (title === "this word") 
     doSomething(); 

y el título fue " this word"

así que tal vez tienen que utilizar trim función como esta

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

Answer 6

I've provided some code (iguales que abajo) para explicar el tipo de conversión de JavaScript comparación de igualdad con los ejemplos.

<!-- 

JavaScript has both strict and type-converting equality comparison. For strict equality the objects being compared must have the same 
type, presented by === (the triple equal sign). For strict equality, the objects being compared must be equal in type as well. 
Below I am going to provide you couple examples, I hope they help you! 

Please, don't forget to like my code. Thank you! 

--> 

<!DOCTYPE html> 
<html> 
    <body> 

    <p id="demo"></p> 

    <script> 

     document.write("The == and === comparison" + "<br>" + "<br>"); 
     //document.write(" (0 == false) returns: " + (0 == false) + "<br>"); // true 


     document.write((0 == false) + "<br>"); // true 

     document.write((0 === false) + "<br>"); // false, because they are of a different type 

     document.write((1 == "1") + "<br>"); // true, automatic type conversion for value only 

     document.write((1 === "1") + "<br>"); // false, because they are of a different type 

     document.write(('0' == false) + "<br>"); // true 

     document.write(('0' === false) + "<br>"); // false 

     document.write((2==='2') + "<br>"); //false 

     document.write((2==="2") + "<br>"); //false 

     document.write(("2"===2) + "<br>"); //true 

     document.write((2===2) + "<br>"); //true 

     document.write(("3"==3) + "<br>"); //true 

     document.write((3=='3') + "<br>"); //true 

     document.write((3==true) + "<br>"); //false 


     /*Two numbers are strictly equal when they are numerically equal (have the same number value). */ 
     document.write((3==3) + "<br>"); //true 
     document.write((5.2==5.2) + "<br>"); //true 


     /* Two strings are strictly equal when they have the same sequence of characters, same length, 
      and same characters in corresponding positions. */ 
     document.write(("hola"=="hola") + "<br>"); //true 
     document.write(("hola"=="Hola") + "<br>"); //false, because they differ in a character 'H' 


     /* NaN is not equal to anything, including NaN. Positive and negative zeros are equal to one another. */ 
     document.write(("NaN"=="hola") + "<br>"); //false 
     document.write(("NaN"== -3) + "<br>"); //false 
     document.write(("NaN"== 3) + "<br>"); //false 
     document.write(("NaN"== 2.5) + "<br>"); //false 


     /* Two Boolean operands are strictly equal if both are true or both are false. */ 
     document.write(((0 > 5) == (8 < 9)) + "<br>"); // false, the first condition (0>5) returns false and (8<9) returns true 
     document.write(((8 >= 5) == (8 == 9)) + "<br>"); // false, the first condition (8>=5) returns true and (8==9) returns false 
     document.write(((true) == (true)) + "<br>"); // true 
     document.write(((false) == (false)) + "<br>"); // true 


     /* Null and Undefined types are == (but not ===). [e.g.: (Null==Undefined) is true but (Null===Undefined) is false] */ 
     document.write((null == undefined) + "<br>"); // true 
     document.write((null === undefined) + "<br>"); // false 


     /* 
     Two objects are strictly equal if they refer to the same Object. 
     */ 
     var car1 = {type:"Fiat", model:"500", color:"white"}; 
     var car2 = {type:"Fiat", model:"500", color:"white"}; 
     var x = car1; 

     document.write((car1 === car2)+ "<br> "); // false 
     document.write((car1 == car2)+ "<br> "); // false 
     document.write((car1 === x)+ "<br> "); // true 
     document.write((car1 == x)+ "<br>"); // true 



     /* DO NOT FORGET THAT = (a single equal sign) represents assignment. e.g.: var X = 3; 
     Here we were assigning 3 to variable X 
     */ 

    </script> 

    </body> 
</html> 

Answer 7

Sólo una adición a las respuestas: Si todos estos métodos devuelven falsa, incluso si las cadenas parecen ser iguales, es posible que exista un espacio en blanco a la izquierda y la derecha o de una cadena. Por lo tanto, sólo hay que poner un .trim() al final de las cuerdas antes de comparar:

if(s1.trim() === s2.trim()) 
{...} 

He perdido horas tratando de averiguar lo que está mal. ¡Espero que esto ayude a alguien!