В JavaScript ще срещнете пет оператора, използващи знака за равенство: =
, ==
, ===
, !=
и !==
. =
е доста ясна, но разликите между ==
и ===
и !=
и !==
(и кога да ги използвате) може да изглеждат малко мъгляви в началото, но има ясни и различни употреби за всяка, така че нека се задълбочим!
Първо, кратко споменаване на single е равно на=
, което е просто оператор за присвояване. Ще използвате това, за да присвоите стойността на това, което е отдясно на това, което е отляво:
В този пример съм задал променливата mySnacks
равна на масив, включващ гевреци, ябълки и моркови. Така че има това.
== и === : Проверките на равенството
Всичко, което операторите ==
и ===
правят, е да проверяват за равенство, но го правят в различна степен.
Операторът double equals (==
) се нарича абстрактно или свободно сравнениеоператор, защото стойностите от двете страни на оператора не трябва да бъдат идентичен, за да върне true
. Всъщност начинът, по който работи операторът, е чрез използване на това, което се нарича тип принуда. Това означава, че двете стойности се сравняват само след опит за преобразуването им в общ тип.
Тройното е равно (===
) се нарича оператор за стриктно сравнение, тъй като типът и стойността, които сравняваме, трябва да са еднакви, за да върнем true
.
Нека проучим тази концепция с няколко примера:
Тук свободно сравняваме числото 50
с низа '50'
. Поради принуда на типа, те се четат като свободно еднаква стойност, така че беше върнато true
.
В този пример стриктно сравняваме числото 50
с низа '50'
. Тъй като числото и низът не са от един и същи тип данни, те бяха върнати като false
.
Тук сравнявамебулевите false
и 0
, които и двете са фалшиви, така че се връща true
.
В горното ние стриктно сравняваме false
и 0
, и двете фалшиви стойности, но различни типове и стойности, така че се връща като false
.
!= и !==: Проверката на неравенството
Подобно (но обратно) на ==
и ===
, операторите !=
и !==
проверяват за неравенство.
Операторът за свободно неравенство (!=
) връща true, ако двете стойности, които се сравняват, са слабо равни една на друга. Това работи по същия начин (но обратното) като ==
в смисъл, че се използва принуда на типа за преобразуване на стойностите в общ тип, преди да бъдат сравнени.
Операторът за стриктно неравенство (!==
) връща true, ако двете стойности, които се сравняват, са строго неравни една на друга.
Вижте тези примери:
Тъй като 50
и 51
не са равни едно на друго и ние стриктно сравняваме неравенството между тези стойности, тази функция връща true
.
В горния пример 50
се сравнява стриктно със себе си, така че се връща като false
, тъй като те не са неравни един на друг.
Тук свободно сравняваме числото 50
с низа '50'
. Тъй като се използва принуда на типа, тези стойности се преобразуват в общ тип (в този случай низове), така че те всъщност са равни една на друга, следователно проверката за неравенство се връща като false
.
Бонус: вижте тази удобна таблица, ако сте любопитни относно подробностите за това как работи принудата за тип.
Затваряне
Надявам се, че сте намерили този кратък преглед на операторите за равенство и неравенство в JavaScript полезен! Запомнете, =
се използва само за присвояване на променливи, ==
се използва, когато искате свободно да сравните две стойности/типове, и ===
се използва, когато искате стриктно да сравните две стойности, !=
се използва, когато искате свободно да сравните неравенството между две стойности, и !==
се използва, когато искате стриктно да сравните неравенството между две стойности.