Wat is de juiste manier om te controleren op gelijkheid tussen snaren in JavaScript?
Antwoord 1, Autoriteit 100%
==
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
true
offalse
kan 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 padding
en white-spaces
controleer mijn zaak
if (title === "LastName")
doSomething();
en titel was " LastName"
dus misschien moet je de functie
trim
op deze manier gebruiken
var title = $(this).text().trim();
Antwoord 6, autoriteit 2%
Er zijn eigenlijk twee manieren waarop strings in javascript kunnen worden gemaakt.
-
var str = 'Javascript';
Dit creëert een primitieve tekenreekswaarde. -
var obj = new String('Javascript');
Hiermee wordt een wrapper-object gemaakt
van het typeString
.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.valueOf
de juiste manier.
new String('javascript').valueOf() == new String('javascript').valueOf()
Antwoord 7
String Objects
kunnen 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 search
en 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) + "|");