Wat is de juiste manier om te controleren op stringgelijkheid in JavaScript?

Wat is de juiste manier om te controleren op gelijkheid tussen snaren in JavaScript?


Antwoord 1, Autoriteit 100%

altijd totdat u de verschillen en implicaties volledig begrijpt om de ==en ===Operators te gebruiken , gebruik de ===-exploitant omdat het u van obscure (niet-duidelijke) bugs en wtfs zal opslaan. De “Regelmatige” ==Operator kan zeer onverwachte resultaten hebben als gevolg van de intern coëringen, dus met behulp van ===is altijd de aanbevolen aanpak.

Voor inzicht in deze, en andere “Good vs. Slechte” delen van JavaScript lezen de heer Douglas Crockford en zijn werk. Er is een geweldige Google Tech Talk waar hij veel goede info vat: http://www.youtube.com / horloge? v = hqvtijbzook


update:

De u weet niet JS serie door Kyle Simpson is uitstekend ( en vrij om online te lezen). De serie gaat naar de algemeen verkeerd begrepen gebieden van de taal en verklaart de “slechte delen” die Crockford suggereert dat u vermijdt. Door hen te begrijpen, kunt u er een goed gebruik van maken en de valkuilen vermijden.

De “up & amp; gaan ” Boek bevat een sectie op gelijkheid , met deze specifieke samenvatting van wanneer de losse (==) vs Strict (===) Operators:

Om een heleboel details terug te brengen tot een paar eenvoudige afhaalrestaurants, en om u te helpen weten of u ==of ===in verschillende situaties moet gebruiken, vindt u hier mijn eenvoudige regels:

  • Als een van beide waarden (ook wel kant) in een vergelijking de waarde trueof falsekan zijn, vermijd dan ==en gebruik ===.
  • Als een van beide waarden in een vergelijking van deze specifieke waarden zou kunnen zijn (0, ""of []— lege array) , vermijd ==en gebruik ===.
  • In alleandere gevallen kunt u veilig ==gebruiken. Het is niet alleen veilig, maar in veel gevallen vereenvoudigt het uw code op een manier die de leesbaarheid verbetert.

Ik raad Crockford’s talk nog steeds aan voor ontwikkelaars die niet de tijd willen investeren om Javascript echt te begrijpen – het is een goed advies voor een ontwikkelaar die slechts af en toe met Javascript werkt.


Antwoord 2, autoriteit 33%

Als je weet dat het strings zijn, hoef je niet op type te controleren.

"a" == "b"

Houd er echter rekening mee dat string-objecten niet gelijk zullen zijn.

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

zal false retourneren.

Roep de methode valueOf() aan om deze te converteren naar een primitief voor String-objecten,

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

zal true retourneren


Antwoord 3, autoriteit 11%

Slechts één toevoeging aan de antwoorden: als al deze methoden false retourneren, zelfs als strings gelijk lijken te zijn, is het mogelijk dat er links en/of rechts van een string een witruimte is. Zet dus gewoon een .trim()aan het einde van strings voordat je gaat vergelijken:

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

Ik heb uren verloren om erachter te komen wat er mis is.
Ik hoop dat dit iemand zal helpen!


Antwoord 4, autoriteit 7%

Je kunt ==of ===gebruiken, maar de laatste werkt op een eenvoudigere manier (src)

a == b(en de ontkenning !=)

a === b(en de ontkenning !==)


Antwoord 5, autoriteit 4%

wat me tot deze vraag leidde, zijn de paddingen white-spaces

controleer mijn zaak

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

en titel was " LastName"

dus misschien moet je de functie trimop deze manier gebruiken

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

Antwoord 6, autoriteit 2%

Er zijn eigenlijk twee manieren waarop strings in javascript kunnen worden gemaakt.

  1. var str = 'Javascript';Dit creëert een primitieve tekenreekswaarde.

  2. var obj = new String('Javascript');Hiermee wordt een wrapper-object gemaakt
    van het type String.

    typeof str // string
    typeof obj // object

Dus de beste manier om op gelijkheid te controleren, is door de operator ===te gebruiken, omdat deze zowel de waarde als het type van beide operanden controleert.

Als je wilt controleren op gelijkheid tussen twee objecten, dan is het gebruik van String.prototype.valueOfde juiste manier.

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

Antwoord 7

String Objectskunnen worden gecontroleerd met de JSON.stringify()-truc.

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

Antwoord 8

Aangezien beide strings erg groot kunnen zijn, zijn er 2 hoofdbenaderingen bitwise searchen localeCompare

Ik heb deze functie aanbevolen

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

Antwoord 9

Strenge vergelijkingen

Als u een eenvoudige vergelijking wilt maken, gebruikt u ===om te controleren op strikte gelijkheid. Zoals anderen al zeiden, heeft dit de voordelen dat het het meest efficiënt is en de kans op fouten of onzekere code verkleint. Bron: MDN Web Docs: Strict Equality.

var a = "hello1";
var b = "hello2";
console.log("a === a?" + (a === a) + "|");
console.log("a === b?" + (a === b) + "|");

Other episodes