JSLint ожидал '===' и вместо этого увидел '=='

Question

Недавно я выполнил часть своего кода через JSLint, когда обнаружил эту ошибку.Что мне смешно в этой ошибке, так это то, что она автоматически предполагает, что все == должно быть ===.

Это действительно имеет какой-то смысл?Я мог видеть много случаев, когда вы не хотели бы сравнивать тип, и я обеспокоен тем, что это может вызвать проблемы.

Слово «Ожидаемый» подразумевает, что это следует делать КАЖДЫЙ раз .....Это то, что не имеет смысла для меня.

Answer 1

ИМО, вслепую используя ===, не пытаясь понять , как преобразование типов работает, не имеет особого смысла.

Первичный страх об операторе Equals == заключается в том, что правила сравнения в зависимости от сравниваемых типов могут сделать оператор нетранзитивным, например, если:

A == B AND
B == C

На самом деле не гарантирует, что:

A == C

Например:

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

Оператор строгого равенства === на самом деле не нужен при сравнении значений одного типа, наиболее распространенный пример:

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

Мы сравниваем результат оператора typeof, который всегда a string , с string literal ...

Или, когда вы знаете, например, правила приведения типов, проверьте, является ли что-то 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
}

Answer 2

JSLint по своей природе более защищен, чем допускает синтаксис Javascript.

Из документации JSLint:

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

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

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

(foo != 0)

просто скажите

(foo)

и вместо

(foo == 0)

скажем

(!foo)

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

Answer 3

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

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

Answer 4

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

Итак, ("4" == 4)true, тогда как ("4" === 4) - false.

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

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

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

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

Answer 5

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

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

Почти всегда лучше использовать операторы === и! ==.Операторы == и! = Выполняют приведение типов.В частности, не используйте == для сравнения с ложными значениями.

JSLint очень строг, их 'webjslint.js' даже не проходит собственную проверку.

Answer 6

Чтобы объяснить этот вопрос, а также объяснить, почему NetBeans (с) 7.3 начал показывать это предупреждение, это выдержка из ответа на средстве отслеживания ошибок NetBeans, когда кто-то сообщил об этом как об ошибке:

Рекомендуется использовать === вместо == в JavaScript.

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

1010 * Reference *

Answer 7

Если вы хотите проверить на ложность. JSLint не позволяет

if (foo == null)

но разрешает

if (!foo)

Answer 8

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