Почему JavaScript не имеет строгого/меньшего числа операторов сравнения?

В то время как JavaScript-строгие операторы сравнения типов (===, !==) хороши, у него нет соответствующих строгих сравнений для большего/меньшего.

var x = 10;

x <= 20;    // true
x <= '20';    // true
x <== 20;   // true (or would be, if JS had such an operator)
x <== '20'; // false (ditto)

Почему бы и нет? Я задаю этот вопрос, полностью ожидая, что ответ будет "ну, потому что это не так", но я все равно спрашиваю, если есть интересная и/или удручающая историческая причина для того, чтобы такие операторы были опущены.

Ответ 1

Я могу только догадываться -

Если
a === b является ложным, а затем a !== b истинно. всегда.

Но эта импликация не будет выполняться для <==

Если
x <== 20 является ложным, мы не можем вывести результат x >== 20, потому что это могло быть ложным из-за проверки типа или проверки отношения.

Я думаю, что это немного запутанно, хотя на языке гораздо хуже, чем на другом (напр., принуждение вообще назвать его).

Однако, я думаю, что строгие < или > будут вести себя последовательно.

Ответ 2

Так как a === b является сокращением для typeof a == typeof b && a == b, вы можете использовать это расширение для неравенств: typeof a == typeof b && a <= b например.

Ответ 3

Я не уверен, что есть ответ на ваш вопрос. Я предполагаю, что предполагаемое использование предназначено для сравнения чисел с строками (и, возможно, булевыми). Это действительно работает для этих случаев, как это делает нестрогий оператор равенства. В любом случае все остальное подчиняется правилам принуждения произвольного типа. Каким будет "правильный" вывод [] < {}? false? Может быть, undefined? Обратите внимание, что типы даже не должны быть разными, ({foo: 1}) < {bar : 2} также не имеет никакого смысла.

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

Ответ 4

Чтобы показать, почему это не имеет смысла, подумайте об этом...

var x = 10
var less = (x <= 5)

Теперь оба

x <== 5

x <== '5'

будет ложным, но по разным причинам. В первом случае вы можете использовать предположение, что x > 5, но не в последнем случае. Чтобы избежать ложных предположений, лучше использовать === или! == сначала, а затем сравнение после.

Ответ 5

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

Предположим, что строгий компаратор a <== b должен быть typeof a == typeof b && a <= b. И то же самое для a >== b. Затем мы сравниваем a = "3" и b = 3, а результаты: a <== b false, a >== b false и a === b false. Поздравляем, вы просто создали парадокс!

Такой строгий компаратор все равно испортил бы такие вещи, как алгоритмы сортировки или сравнение неожиданных значений. Например:

for (var i; i <== list.count; i++) {
  doStuff(i);
}

Обратите внимание, что пример ошибочно использует list.count вместо list.length, который просто вернет undefined, который просто вернет false по сравнению с i <== undefined, поэтому цикл for будет полностью пропущен к удивлению программиста.

Мне было бы намного лучше, если бы JavaScript поднял ошибку на list.count для Undefined Свойство, а также при сравнении разных типов.

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

Это означает, что фактическое практическое решение состоит в том, чтобы начать использовать препроцессоры или просто сказать "О, хорошо" и продолжать печатать JavaScript ¯\_(ツ)_/¯