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:

==И !=операторы делают тип принуждения перед сравнением. Это плохо, потому что это ' \t\r\n' == 0правда. Это может замаскировать типовые ошибки.

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

Если вас беспокоит только то, что значение является правдивым или ложным , используйте краткую форму. Вместо того

(foo != 0)

просто скажи

(foo)

и вместо

(foo == 0)

сказать

(!foo)

Операторы ===и !==являются предпочтительными.

Имейте в виду, что JSLint навязывает одному человеку представление о том, каким должен быть хороший JavaScript. Вам по-прежнему нужно руководствоваться здравым смыслом при реализации предлагаемых им изменений.

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

Тройное равенство отличается от двойного равенства, потому что помимо проверки того, являются ли две стороны одинаковыми значениями, тройное равенство также проверяет, что они имеют один и тот же тип данных.

Так ("4" == 4)верно, тогда ("4" === 4)как ложно.

Triple-equal также работает немного быстрее, потому что 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 не может надежно определить, правильно ли используется ==, поэтому лучше вообще не использовать == и! = И всегда использовать вместо них более надежные операторы === и! ==.

Справка

На самом деле это не может вызвать проблем, это просто совет. Возьми это или оставь. Тем не менее, я не уверен, насколько это умно. Вполне могут быть контексты, в которых это не представляет собой проблему.