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

Ответ 1

IMO, слепо используя ===, не пытаясь понять, как работает преобразование типов, не имеет большого смысла.

Основной страх перед оператором 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
}

Ответ 2

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

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

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

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

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

(foo != 0)

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

(foo)

и вместо

(foo == 0)

говорят

(!foo)

Предпочтительны операторы === и !==.

Ответ 3

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

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

Ответ 4

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

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

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

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

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

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

Ответ 5

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

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

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

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

Ответ 6

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

Ответ 7

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

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

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

Ссылка

Ответ 8

Если вы хотите проверить фальсификацию. JSLint не разрешает

if (foo == null)

но позволяет

if (!foo)