JSLint очікується '===', а замість цього побачить '=='

Нещодавно я запускав частину свого коду через JSLint, коли прийшов із цією помилкою. Однак, на мою думку, смішно щодо цієї помилки полягає в тому, що вона автоматично передбачає, що все == має бути ===.

Чи справді це має якийсь сенс? Я бачив багато випадків, коли ви не хотіли б порівнювати тип, і я переживаю, що це насправді може спричинити проблеми.

Слово "очікуваний" означатиме, що це слід робити КОЖИЙ раз ..... Це те, що для мене не має сенсу.

ІМО, наосліп ===, не намагаючись зрозуміти, як працює перетворення типів , не має особливого сенсу.

Основний страх щодо оператора Equals ==полягає в тому, що правила порівняння в залежності від типів, що порівнюються, можуть зробити оператор неперехідним, наприклад, якщо:

A == B AND
B == C

Не гарантує, що:

A == C

Наприклад:

'0' == 0;   // true
 0  == '';  // true
'0' == '';  // false

Оператор Strict Equals ===насправді не потрібен при порівнянні значень одного типу, найпоширеніший приклад:

if (typeof foo == "function") {
  //..
}

Ми порівнюємо результат typeofоператора, який завжди є рядком , із рядковим літералом ...

Або , коли ви знаєте правила примусу типу, наприклад, перевірити , якщо що - то nullчи undefinedщо - то:

if (foo == null) {
  // foo is null or undefined
}

// Vs. the following non-sense version:

if (foo === null || typeof foo === "undefined") {
  // foo is null or undefined
}

JSLint за своєю суттю є більш захисним, ніж дозволяє синтаксис Javascript.

З документації JSLint:

Оператори ==and !=виконують примусовий тип перед порівнянням. Це погано, тому що це викликає ' \t\r\n' == 0істину. Це може замаскувати помилки типу.

При порівнянні з будь-яким із наведених нижче значень використовуйте оператори ===або !==(які не виконують примусу типу):0 '' undefined null false true

Якщо ви тільки піклуватися про те , що значення truthy або falsy , а потім використовувати скорочену форму. Замість

(foo != 0)

просто сказати

(foo)

а замість

(foo == 0)

сказати

(!foo)

===І !==оператори є кращими.

Майте на увазі, що JSLint застосовує уявлення про те, яким хорошим JavaScript повинен бути. Вам все одно доведеться використовувати здоровий глузд під час впровадження запропонованих змін.

Загалом, порівняння типу та значення зробить ваш код безпечнішим (ви не зіткнетеся з несподіваною поведінкою, коли перетворення типу не зробить того, що, на вашу думку, має бути).

Потрійна рівність відрізняється від подвійної рівності, оскільки крім перевірки того, чи є дві сторони однаковими, трикратна рівність також перевіряє, що вони однакового типу даних.

Так ("4" == 4)правда, тоді ("4" === 4)як хибна.

Triple-jednak також працює трохи швидше, тому що JavaScript не повинен витрачати час на будь-які перетворення типів, перш ніж дати вам відповідь.

JSLint навмисно націлений на те, щоб зробити ваш код JavaScript максимально суворим, з метою зменшення незрозумілих помилок. Це підкреслює подібні речі, намагаючись змусити вас кодувати так, щоб змусити вас поважати типи даних.

Але хороша річ у JSLint полягає в тому, що це лише керівництво. Як кажуть на сайті, це зашкодить вашим почуттям, навіть якщо ви дуже хороший програміст JavaScript. Але ви не повинні почуватись зобов'язаними слідувати його порадам. Якщо ви прочитали, що там сказано, і розумієте, але впевнені, що ваш код не зламається, тоді вас не змушують щось змінювати.

Ви навіть можете сказати JSLint ігнорувати категорії перевірок, якщо ви не хочете, щоб вас обстрілювали попередженнями, що ви нічого не збираєтеся робити.

Цитата з http://javascript.crockford.com/code.html :

=== та! == Оператори.

Майже завжди краще використовувати оператори === та! ==. Оператори == та! = Виконують примус типу. Зокрема, не використовуйте == для порівняння проти хибних значень.

JSLint дуже суворий, їх 'webjslint.js' навіть не проходить власну перевірку.

Якщо ви хочете перевірити на хибність. JSLint не дозволяє

if (foo == null)

але дозволяє

if (!foo)

Щоб допомогти пояснити це питання, а також пояснити, чому NetBeans (з) 7.3 почав показувати це попередження, це витяг із відповіді на відстежувач помилок NetBeans, коли хтось повідомив про це як про помилку:

Рекомендується використовувати ===, а не == в JavaScript.

Оператори == та! = Виконують примусовий тип перед порівнянням. Це погано, оскільки спричиняє істину '\ t \ r \ n' == 0. Це може замаскувати помилки типу. JSLint не може надійно визначити, чи == використовується правильно, тому найкраще взагалі не використовувати == та! = І замість цього завжди використовувати надійніші оператори === та! ==.

Довідково

Ну, насправді це не може викликати проблем, це просто надання вам поради. Прийняти його або залишити його. Тим не менш, я не впевнений, наскільки це розумно. Цілком можуть бути контексти, в яких це не представляє це як проблему.