Почему это плохая идея позволить их в JavaScript ==! =, ++,-

Поведение стандартных операторов равенства (== и! =) Зависит от версии JavaScript. Это одна из причин, по которой их не используют.

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

См. https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operators/Comparison_Operators

Я понимаю == . (исключение undefined == null )

("0" == false) === true
("0" === false) === false

Я никогда не понимал ++ и - . Мне не нравится использовать i + = 1 во всем моем коде (это медленнее, чем ++ i ).

У Дуга Крокфорда есть свои представления о том, что такое «хорошее» и «плохое» в Javascript. Соответственно, JSLint реализует эти проверки, но делает их необязательными, если вы не полностью с ним согласны.

Запрещение == помогает предотвратить ошибки, когда вы на самом деле имели в виду === . Конечно, это предполагает, что вы никогда не захотите использовать == .

Запрещение ++ и - - это стиль, некоторые люди считают, что их труднее читать, чем + = 1 и - = 1 .

Операторы == и ! = неявно выполняют преобразование операторов, если необходимо, а операторы === и ! == - нет. Например, выражение 4 == '4' будет истинным, а выражение 4 === '4' будет ложным.

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

Операторы ++ и - не вызывают никаких проблем, если они используются в операторе отдельно, но они часто используются для создания оператора, который делает больше, чем одна вещь не столь очевидным образом, например:

arr[++idx] = 42;

что было бы яснее, как:

idx += 1;
arr[idx] = 42;

Из инструкции:

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

и

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

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

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

A == B AND
B == C

Не гарантирует, что:

A == C

Реальный пример:

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

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

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

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

Другой пример, когда вы сравниваете что-то с null, == также сравнивает с undefined, например:

if (something == null) {}

VS

if (something === null || typeof something === "undefined") {}

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

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

Рекомендуемые статьи:

• ECMAScript. Операторы равенства (Отличные советы, чтобы запомнить, как работает ==)
• typeof, == и ===