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

javascript compare strings

Question

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

Answer 1

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

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

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, utilizar String.prototype.valueOf es la forma correcta.

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

Answer 2

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

revisa mi caso

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

y el título era " LastName"

así que tal vez tengas que usar una función de trim como esta

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

Answer 3

Los Objects cadena se pueden verificar utilizando este truco JSON.stringyfy()

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

Answer 4

Se me ocurrió una solución alternativa durante las pruebas. Puede utilizar 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 los navegadores de cromo

Answer 5

Si sabe que son cadenas, entonces 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

Answer 6

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 coloque un .trim() al final de las cadenas antes de comparar:

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

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

Answer 7

siempre Hasta que entienda completamente las diferencias y las implicaciones de usar los operadores == y === , use el operador === ya que lo salvará de errores y WTFs poco claros (no obvios). El operador "regular" == puede tener resultados muy inesperados debido a la coacción de tipo internamente, por lo que usar === es siempre el enfoque recomendado.

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

Actualizar:

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

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

Para resumir una gran cantidad de detalles a unos pocos comentarios simples, y ayudarlo a saber si debe usar == o === en diversas situaciones, aquí están mis reglas simples:

• Si cualquiera de los valores (también conocido como lado) en una comparación podría ser el valor true o false , 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), evite == y use === .
• En todos los demás casos, es seguro 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 los desarrolladores que no quieren invertir el tiempo para entender realmente el Javascript. Es un buen consejo para un desarrollador que solo ocasionalmente trabaja con Javascript.

Answer 8

A menos que realmente sepa cómo funciona la coerción, debe evitar == y usar el operador de identidad === lugar. Pero debes leer esto para entender cómo funciona .

Si 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 dijo Douglas Crockford en su libro:

Siempre es mejor usar el operador de identidad.