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

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

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

слово "ожидаемый" будет означать, что это должно быть сделано каждый раз.....Вот что делает не имеет смысла для меня.

8 79
javascript jslint

8 ответов:

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

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

A == B AND
B == C

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

A == C

например:

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

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

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

мы сравниваем результат typeof оператор всегда a строка С строка литерал...

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

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

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

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

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

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

(foo != 0)

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

(foo)

и вместо

(foo == 0)

сказать

(!foo)

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

23

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

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

15

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

Так ("4" == 4) истинно, то ("4" === 4) ложно.

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

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

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

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

12

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

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

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

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

7

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

2

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

Это хорошая практика, чтобы использовать = = = а не == в JavaScript.

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

ссылка

2

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

if (foo == null)

, но не позволяют

if (!foo)
2