Jaki jest prawidłowy sposób sprawdzania równości ciągów w JavaScript?

Jaki jest prawidłowy sposób sprawdzenia równości między ciągami w JavaScript?

zawsze Dopóki nie w pełni zrozumiesz różnice i implikacje korzystania zoperatorów==i===, użyj===operatora, ponieważ uratuje cię to od niejasnych (nieoczywistych) błędów i WTF. „Zwykły”==operator może mieć bardzo nieoczekiwane wyniki ze względu na wewnętrzny przymus typu, więc użycie===jest zawsze zalecanym podejściem.

Aby uzyskać wgląd w to i inne „dobre kontra złe” części Javascript, poczytałem o Douglasie Crockfordie i jego pracy. Jest świetna Google Tech Talk, w której podsumowuje wiele dobrych informacji: http://www.youtube.com/watch?v=hQVTIJBZook

Aktualizacja:

Seria You Don't Know JS autorstwa Kyle'a Simpsona jest doskonała (i do przeczytania online za darmo). Seria omawia często źle rozumiane obszary języka i wyjaśnia „złe strony”, których sugeruje Crockford. Rozumiejąc je, możesz właściwie z nich korzystać i unikać pułapek.

Książka „ Up & Going ” zawiera sekcję dotyczącą równości , z tym konkretnym podsumowaniem, kiedy należy używać operatorów loose ( ==) vs strict ( ===):

Aby sprowadzić wiele szczegółów do kilku prostych dań na wynos i pomóc ci wiedzieć, czy użyć, ==czy ===w różnych sytuacjach, oto moje proste zasady:

• Jeśli którakolwiek wartość (inaczej strona) w porównaniu może być wartością truelub false, należy unikać ==i używać ===.
• Jeśli wartość w porównaniu z nich może być konkretne wartości ( 0, ""lub []- pusta tablica), należy unikać ==i zastosowania ===.
• We wszystkich innych przypadkach możesz bezpiecznie używać ==. Jest nie tylko bezpieczny, ale w wielu przypadkach upraszcza kod w sposób poprawiający czytelność.

Nadal polecam przemówienie Crockforda programistom, którzy nie chcą poświęcać czasu na prawdziwe zrozumienie Javascript - to dobra rada dla programistów, którzy tylko czasami pracują w Javascript.

Jeśli wiesz, że są łańcuchami, nie ma potrzeby sprawdzania typu.

"a" == "b"

Należy jednak pamiętać, że obiekty łańcuchowe nie będą równe.

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

zwróci fałsz.

Wywołaj metodę valueOf (), aby przekształcić ją w operację podstawową dla obiektów String,

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

zwróci prawdę

Tylko jeden dodatek do odpowiedzi: Jeśli wszystkie te metody zwracają wartość false, nawet jeśli łańcuchy wydają się być równe, możliwe jest, że po lewej i / lub prawej stronie jednego łańcucha występuje spacja. Więc po prostu umieść .trim()na końcu łańcucha przed porównaniem:

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

Straciłem godziny, próbując dowiedzieć się, co jest nie tak. Mam nadzieję, że to komuś pomoże!

to, co doprowadziło mnie do tego pytania, to paddingiwhite-spaces

sprawdź moją sprawę

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

i tytuł był " LastName"

więc może musisz użyć trimtakiej funkcji

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

O ile naprawdę nie wiesz, jak działa przymus, powinieneś unikać ==operatora tożsamości i używać go ===. Ale powinieneś przeczytać to, aby zrozumieć, jak to działa .

Jeśli używasz ==, pozwalasz językowi na wykonanie pewnego przymusu, więc na przykład:

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

Jak powiedział Douglas Crockford w swojej książce:

Zawsze lepiej jest użyć operatora tożsamości.

Istnieją dwa sposoby tworzenia łańcuchów w javascript.

1. var str = 'Javascript'; To tworzy prymitywną wartość ciągu.

2. var obj = new String('Javascript');Spowoduje to utworzenie typu opakowania String.

   typeof str // string
typeof obj // object

Zatem najlepszym sposobem sprawdzenia równości jest użycie ===operatora, ponieważ sprawdza on wartość, a także rodzaj obu operandów.

Jeśli chcesz sprawdzić równość między dwoma obiektami, użyj String.prototype.valueOfpoprawnego sposobu.

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

Ciąg Objectsmożna sprawdzić za pomocą JSON.stringyfy()sztuczki.

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

Biorąc pod uwagę, że oba ciągi mogą być bardzo duże, istnieją 2 główne podejścia bitwise searchilocaleCompare

Poleciłem tę funkcję

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

Najłatwiej to zrobić, używając operatora trójskładnikowego:

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

ale jeśli ciąg, który chcesz porównać, znajduje się w tablicy, użyjesz filtru es6

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

powyższe sprawdzi twój stringArray i dowolny ciąg pasujący do niego z tablicy, która w naszym przypadku wybraliśmy „boys”

Podczas testów wymyśliłem alternatywne rozwiązanie. możesz użyć funkcji na prototypie łańcucha.

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

działa dobrze w przeglądarkach Chrome