javascript - Кой оператор е равен (== vs ===) трябва да се използва в сравнение с javascript? - medican.info
Използвам JSLint за преминаване през JavaScript и връща много изречения, които да заменят == (два знака за равенство) с === (три равни знака), когато правите нещо като сравнение idSele_UNVEHtype.value.length == 0 оператор, if .
Има ли предимство за производителност за замяна на == с === ?
Всяко подобрение на производителността ще бъде добре дошло, тъй като има много оператори за сравнение.
Ако преобразуването на типа не се случи, ще се сравни ли печалбата с == ?
11 дек. настроен от bcasp 11 декември 2008-12-11 17:19 '08 в 17:19 2008-12-11 17:19
ответ 51 отговора
Операторът за идентичност ( === ) се държи идентично с оператора за равенство ( == ), с изключение на това, че преобразуването на типа не се извършва, а типовете трябва да са еднакви, за да се считат за равни.
Справка: Урок на Javascript: Оператори за сравнение
Операторът == ще сравни за равенство след извършване на необходимите реализации. Операторът === няма да извърши преобразуването, така че ако двете стойности не съвпадат, то === просто ще върне false . И двете са еднакво бързи.
Цитат Дъглас Крокфорд: отлични javascript: добри части ,
В JavaScript има две групи оператори за равенство: === и !== , и техните зли близнаци == и != . Добрите работят така, както сте очаквали. Ако два операнда от един и същи тип имат една и съща стойност, тогава === създава true и !== произвежда false . Злите близнаци правят правилното нещо, когато операндите са от един и същи тип, но ако имат различни типове, те се опитват да наложат стойности. правилата, чрез които те правят, които са сложни и непреодолими. Ето някои от интересните случаи:
Липсата на транзитивност е тревожна. Моят съвет е никога да не използвате зли близнаци. Вместо това винаги използвайте === и !== . Всички по-горе сравнения показват false с оператора === .
Един добър въпрос беше повдигнат от @Casebash в коментарите и в @Phillipe Laybaert по отношение на типовете справки. За референтни типове == и === действат последователно една с друга (освен в специалния случай).
Специален случай е сравняването на литерала с обект, който оценява същия литерал поради valueOf toString или valueOf . Например, помислете за сравняване на литерал от низ с обект от низ, създаден от конструктора String .
Тук операторът == проверява стойностите на два обекта и връща true , но === вижда, че те не са от един и същ тип и връщат false . Коя е правилна? Това наистина зависи от това, което се опитвате да сравните. Моят съвет е напълно да заобиколите въпроса и просто да не използвате конструктора String за създаване на обекти с низове.
11 дек. Отговор, даден от Bill Lizard на 11 декември 2008-12-11 17:25 '08 в 17:25 ч. 2008-12-11 17:25
Използване на оператора == (Равенство)
Използване на оператора === (Идентичност)
Това се дължи на факта, че операторът за равенство == има тип принуда , което означава, че интерпретаторът имплицитно се опитва да преобразува стойностите преди сравнението.
От друга страна, операторът Identity === не изпълнява тип принуда и следователно не преобразува стойности при сравняване.
11 дек. Отговорът е даден от Andreas Grech 11 декември. 2008-12-11 17:33 '08 в 17:33 2008-12-11 17:33
В отговорите тук не бях прочел нищо за това какво означава равно . Някои ще кажат, че === означава равен и от същия тип , но не е така. В действителност, това означава, че и двата операнда се отнасят до един и същ обект или, в случай на типове стойности , имат една и съща стойност .
Така че нека вземем следния код:
Същото тук:
Това не винаги е очевидно. В историята има нещо повече, отколкото да бъдеш равен и от същия тип.
За типове стойности (числа):
a === b връща true, ако a и b имат една и съща стойност и имат същия тип
За референтни типове:
a === b връща true, ако a и b отнасят за един и същ обект.
За низове:
a === b връща true, ако a и b са и двете низове и съдържат едни и същи символи.
Струни: специален случай ...
Стрингите не са типове стойности, но в Javascript те се държат като типове стойност, така че те ще бъдат "равни", когато символите в низа са еднакви и когато са със същата дължина (както е обяснено в третото правило)
Сега става интересно:
Но какво ще кажете за това?
Мислех, че низовете се държат като типове стойност? Е, това зависи от кого питате ... В този случай, a и b не са от един и същи тип. a е от тип Object и b е от тип string . Само не забравяйте, че създаването на низ обект, използващ конструктора на string създава нещо като типа Object , който се държи през повечето време като низ.
05 июня '09 в 22:11 2009-06-05 22:11 отговори на Philippe Leybaert на 05.06.09 в 10:11 2009-06-05 22:11
Интересно графично представяне на сравнението на равенството между == и === .
Източник: http://dorey.github.io/JavaScript-Equality-Table/
Когато използвате === за тестване на JavaScript равенството, всичко е както е. Преди оценката нищо не се преобразува.
05 мая '14 в 8:21 2014-05-05 08:21 отговорът е даден от SNag на 05 май 14 в 8:21 2014-05-05 08:21
Нека добавя този съвет:
Ако имате съмнения, прочетете спецификацията !
ECMA-262 е спецификация на скриптовия език, в която JavaScript е диалект. Разбира се, на практика е важно как се държат най-важните браузъри, а не езотеричната дефиниция как трябва да се работи с нещо. Но е полезно да се разбере защо новият String ("a")! == "a" .
Моля, позволете ми да обясня как да прочетете спецификацията, за да изясня този въпрос. Виждам, че в тази много стара тема никой не получи отговор за много странен ефект. Така че, ако можете да прочетете спецификацията, тя ще ви помогне много в професията ви. Това е придобито умение. Така че, давай.
Намирането на PDF файл за === ме води до страница 56 от спецификацията: 11.9.4. Операторът Strict Equals (===) и след преминаване през спецификацията намирам:
11.9.6 Алгоритъм за стриктно сравняване на равенството
Сравняване на x === y, където x и y са стойности, създава true или false . Такова сравнение се извършва, както следва:
1. Ако Type (x) е различен от Type (y), върнете false .
2. Ако type (x) е Undefined, върнете true .
3. Ако Type (x) е Null, върнете true .
4. Ако Type (x) не е число, преминете към стъпка 11. \ t
5. Ако x е NaN , върнете false .
6. Ако y е NaN , върнете false .
7. Ако x е същата цифрова стойност като y, върнете true .
8. Ако x е +0 и y е -0, върнете true .
9. Ако x е -0 и y е +0, върнете true .
10. Върнете false .
11. Ако Type (x) е String, върнете true, ако x и y са точно една и съща последователност от символи (една и съща дължина и еднакви символи в съответните позиции); в противен случай, върнете false .
12. Ако Type (x) е boolean, върнете true, ако x и y са истина или и двете са false ; в противен случай, върнете false .
13. Върнете true, ако x и y принадлежат към един и същ обект или се отнасят към обекти, свързани помежду си (вж. 13.1.2). В противен случай, върнете false .
Интересен е етап 11. Да, струните се третират като типове стойности. Но това не обяснява защо новата String ("a")! == "a" . Имаме ли браузър без ECMA-262?
Проверете видовете операнди. Опитайте сами, като ги опаковате в typeof () . Открих, че новият String ("a") е обект, а стъпка 1 се използва: return false, ако типовете са различни.
Ако се чудите защо новият String ("a") не връща низ, какво ще кажете за някои упражнения, които четат спецификацията? Забавлявайте се!
Aidiakapi написа това в коментар по-долу:
От спецификацията
11.2.2 Нов оператор :
Ако типът (конструктор) не е обект, повдигнете изключението TypeError.
С други думи, ако низът не е от тип Object, той не може да се използва с новия оператор.
new винаги връща обект, дори и за конструкторите на низове . И уви! Семантиката на стойността за низове (виж Стъпка 11) се губи.
И накрая това означава: новия String ("а")! == "a" .
28 нояб. Отговорът е даден на 28 ноември. 2009-11-28 21:18 '09 в 21:18 2009-11-28 21:18
В PHP и JavaScript това е оператор за стриктно равенство. Това означава, че ще сравнява типа и стойностите.
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от Шики на 12 май '10 в 15:58 2010-05-12 15:58
Изпробвах го във Firefox с Firebug, използвайки следния код:
Моите резултати (проверени пет пъти и осреднени):
Така че, бих казал, че една малка разлика (това е повече от 100 000 повторения, не забравяйте) е незначителна. Изпълнението не е причина === . Вид на сигурността (добре, толкова безопасно, колкото ще JavaScript), както и качеството на кода.
25 дек. Отговорът е даден от Саймън Скарфе на 25 декември. 2008-12-25 14:17 '08 в 14:17 ч. 2008-12-25 14:17
В JavaScript това означава една и съща стойност и тип.
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от Димитър на 12 май '10 в 15:58 2010-05-12 15:58
Операторът === се нарича оператор за стриктно сравнение, той е различен от оператора == .
Вземете 2 vars a и b.
За "a == b", за да се оцени истинността на a и b трябва да бъде една стойност .
В случай на "а === b" а и b трябва да са една и съща стойност , както и един и същ тип, за да може да се оцени истината.
Вземете следния пример
В заключение ; Използването на оператора == може да бъде оценено като вярно в ситуации, в които не го желаете, така че използването на оператора === ще бъде по-безопасно.
В сценария с 90% използване няма значение кой ще използвате, но е полезно да знаете разликата, когато един ден получите някакво неочаквано поведение.
11 дек. Отговорът е даден от Доктор Джоунс 11 декември. 2008-12-11 17:58 '08 в 17:58 ч. 2008-12-11 17:58
Той проверява дали същите страни са еднакви по вид и стойност .
Друг често срещан пример е:
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от vsync на 12 май '10 в 15:58 2010-05-12 15:58
Защо == толкова непредсказуемо?
Какво получавате, когато сравните празния низ с номера 0 0 ?
Да, това е правилно в съответствие с == празен низ, а числовата нула е едно и също време.
И това не свършва дотук, друго:
Нещата стават много странни с масивите.
След това с низове
Кога не е равно на?
Нека пак го кажа:
И това са само лудите неща, които получавате с примитиви.
Това е ново ниво на лудост, когато използвате == с обекти.
На този етап вероятно се чудите ...
Добре, защото за разлика от "тройното равенство" ( === ), което просто проверява дали двете стойности съвпадат.
== цял куп други неща .
Той има специална обработка за функции, специална обработка за нули, неопределени, низове, които наричате.
Тя става доста тъпа.
Всъщност, ако се опитате да напишете функция, която прави това, което прави == , тя ще изглежда по следния начин:
Това означава, че == е сложно.
Тъй като е трудно, трудно е да се разбере какво ще се случи, когато го използвате.
Това означава, че може да имате грешки.
Така че моралът на историята ...
Направете живота си по-малко сложен.
Използвайте === вместо == .
09 авг. отговорът е даден от Луис Перес 09 август. 2016-08-09 19:50 '16 в 19:50 2016-08-09 19:50
Диаграма за последователност на изпълнение на Javascript за стриктно равенство / Сравнение '==='
05 сент. отговорът е даден на Самар Панда 05 сеп. 2015-09-05 16:53 '15 в 16:53 2015-09-05 16:53
03 июля '13 в 7:08 2013-07-03 07:08 отговорът е даден от user2496033 03 юли '13 в 7:08 2013-07-03 07:08
Това означава равенство без принуда от типа, което означава, че JavaScript не превръща автоматично никакви други типове данни в низови типове данни.
12 мая '10 в 15:59 2010-05-12 15:59 отговорът е даден от Поп Каталин на 12 май '10 в 15:59 2010-05-12 15:59
В един типичен скрипт няма да има разлика в производителността. По-важното е, че фактът, че хиляда "===" е 1 килобайт, е по-тежък от хиляда "==" :) Профилерите на JavaScript могат да ви кажат дали има разлика в производителността във вашия случай.
Но лично аз бих направил това, което JSLint предлага. Тази препоръка не се дължи на проблеми с производителността, а поради ограничение на типа ('\t\r\n' == 0) .
16 дек. отговор, даден Константин 16 декември. 2008-12-16 17:29 '08 в 17:29 ч. 2008-12-16 17:29
Равен оператор за сравнение == е объркан и трябва да се избягва.
Ако живеете с HAVE , запомнете следните 3 неща:
Не е транзитивно: (a == b) и (b == c) не води до (a == c)
Той взаимно изключва неговото отрицание: (a == b) и (a! = B) винаги имат противоположни булеви стойности с всички a и b.
Когато се съмнявате, запомнете следната таблица на истината:
ТАБЛИЦА НА ПРАВЕН ОПЕРАТОР В ЯВАСКРИПТ
Всеки ред в таблицата е набор от 3 взаимно "равни" стойности, което означава, че всички 2 стойности от тях са равни, използвайки знака за равенство == *
** STRANGE: имайте предвид, че всички две стойности в първата колона не са равни в този смисъл. **
16 сент. отговор, даден от CuongHuyTo 16 септември 2011-09-16 17:25 '11 в 17:25 2011-09-16 17:25
Едва ли има разлика в производителността между двете операции във вашата употреба. Не се извършва преобразуване на типа, тъй като и двата параметъра са от един и същи тип. И двете операции ще имат тип сравнение, последвано от сравнение на стойности.
11 дек. отговор даден Шон 11 декември 2008-12-11 17:44 '08 в 17:44 2008-12-11 17:44
Да! Това има значение.
=== в javascript проверява стойността, както и типа , където операторът == просто проверява стойността (конвертира типа, ако е необходимо) .
14 нояб. Отговор, даден от Аникет Тхакур 14 ноември 2014-11-14 09:02 '14 в 9:02 2014-11-14 09:02
=== проверява стойностите, както и типовете променливи за равенство.
== просто проверява стойността на променливите за равенство.
12 мая '10 в 16:03 2010-05-12 16:03 отговорът е даден от Niraj Choubey на 12 май '10 в 16:03 часа
Това е строг тестов тест.
Това е добре, особено ако проверявате между 0 и false и null.
Всичко връща вярно и може да не го искате. Да предположим, че имате функция, която може да върне индекса на 0-ия масив или фалшивата грешка. Ако поставите отметка в квадратчето с "==" false, можете да получите объркващ резултат.
Така че, със същото, както по-горе, но строг тест:
12 мая '10 в 16:19 2010-05-12 16:19 Отговор е даден Даниел 12 май '10 в 16:19 2010-05-12 16:19
JSLint понякога дава нереалистични причини за промяна на материала. === има същата производителност като == ако типовете вече съвпадат.
Това е по-бързо само ако типовете не съвпадат, в който случай не се опитва да конвертира типове, а връща false.
Така че, IMHO, JSLint може да се използва за писане на нов код, но безполезната оптимизация трябва да се избягва на всяка цена.
Значение, няма причина да се променя == на === в тест, например if (a == 'test') , когато го знаете, защото фактът може да бъде само String.
Промяната на голямо количество код по този начин отнема време на разработчици и рецензенти и не постига нищо.
05 июня '12 в 10:53 2012-06-05 10:53 отговор, даден пепел на 05 юни '12 в 10:53 2012-06-05 10:53
== означава сравнение между операндите с type conversion
=== означава сравнение между операндите без type conversion
Конвертирането на типа в javaScript означава, че javaScript автоматично конвертира всякакви други типове данни в низови типове данни.
20 марта '15 в 8:05 2015-03-20 08:05 отговор е даден Амит 20 март '15 в 8:05 2015-03-20 08:05
Един прост пример е
14 мая '15 в 17:45 2015-05-14 17:45 отговорът е даден от Vikas на 14 май в 17:45 часа 2015-05-14 17:45
Топ 2 отговора за двете споменати == означава равенство и === означава идентификатор. За съжаление, това твърдение е неправилно.
Ако и двата операнда в == са обекти, те се сравняват, за да се види дали те са един и същ обект. Ако и двата операнда сочат към един и същ обект, операторът на равенството връща true. В противном случае, они не равны.