В Javascript значение = = "" равно true. Почему это так?

Если я делаю 0 = = "0", он вычисляется как true. Попробуй,

if( -777 == "-777" ) alert("same");

оповещение происходит.

и также заметно, что true = = "true" не оценивается как true. Попробуй,

if( false == "false" ) alert("same");

оповещения не происходит.

почему это так?

10
comparison javascript variables

8 ответов

поведение == немного длинное, но четко определено в есма-262 спецификаций:

11.9.3 Абстрактный Алгоритм Сравнения

сравнение x == y, где x и y ценности, выдает true или false. Такое сравнение выполняется как следует:

  1. если тип (x) отличается от типа(y), перейдите к шагу 14.
  2. если тип(x) не определен, верните true.
  3. если Тип (x) равен Null, возвращает true.
  4. если тип (x) не является номером, перейдите к шагу 11.
  5. если x-NaN, верните false.
  6. если y-NaN, верните false.
  7. если x такое же числовое значение, как y, верните true.
  8. если x равно +0, а y равно -0, верните true.
  9. если x равно -0, а y равно +0, верните true.
  10. возвращает false.
  11. если тип (x) является строкой, то верните true, если x и y точно такие же последовательность символов (одинаковой длины и те же символы в соответствующих должностное положение.) В противном случае возвращает false.
  12. если тип (x) является логическим, верните true, если x и y оба true или оба ложный. В противном случае возвращает false.
  13. возвратите true если x и y ссылаются на тот же объект или если они ссылаются на объекты соединяются друг с другом (см. 13.1.2). В противном случае возвращает false.
  14. если x равно null, а y не определено, верните true.
  15. если x не определено и y равно null, возвращает true.
  16. если Type (x) - номер, а Type(y) - строка, верните результат сравнение x == ToNumber (y).
  17. если Type (x) - строка, а Type (y) - число, верните результат сравнение ToNumber (x) = = y.
  18. если тип(x) является логическим, верните результат сравнения ToNumber (x) == y.
  19. если тип (y) является логическим, верните результат сравнения x == ToNumber (y).
  20. если тип (x) либо строка, либо номер и тип (y) - Object, return результат сравнения x == ToPrimitive (y).
  21. если Type (x) - Объект, А Type(y) - строка или число, верните результат сравнения ToPrimitive (x) = = y.
  22. возвращает false.

Шаг 16 относится к вашему предыдущему примеру:

   0 == "0"            // apply 16
≡  0 == toNumber("0")
≡  0 == 0              // apply 7
≡  true

и шаг 18 Шаг 16 примените к последнему:

   true == "true"            // apply 18
≡  toNumber(true) == "true"
≡  1 == "true"               // apply 16
≡  1 == toNumber("true")
≡  1 == NaN                  // apply 6
≡  false
32

делаю так:

if(5 == "5")

заставляет javascript преобразовать первые 5 в строку. Попробуйте это:

if(5 === "5")

на === делает Javascript также оценивать тип.

это на самом деле дубликат этого question где это объясняется очень хорошо.

12

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

alert ("5" - 1);  // 4  (int)
alert ("5" + 1);  // "51" (string) "+" is a string operator, too
alert ("5" == 5); // true

то, что вы, возможно, захотите посмотреть, это личность проверка (===). Это гарантирует, что переменные одинаковых не только равной.

alert("5" == 5);  // true, these are equal
alert("5" === 5); // false, these are not identical.

Также см. Этот вопрос: чем отличаются операторы сравнения равенства и идентичности? Реализация PHP очень похожа на javascript.

7

JavaScript имеет два набора операторов равенства:

  • === and !== (операторы строгого равенства)
  • == and != (стандартные операторы равенства)

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

'' == '0' // false
0 == '' // true
0 == '0' // true
false == 'false' // false
false == '0' // true
false == undefined // false
false == null // false
null == undefined // true
' \t\r\n ' == 0 // true

для этого я всегда рекомендую использовать строгие операторы равенства (===, !==).

4

Javascript не приводит " false "к логическому false, только к строке"false".

вы можете свободно привести строковые значения к их целочисленному эквиваленту, поэтому ваш первый пример работает.

1

Javascript-это слабо типизированный язык, поэтому типажи выполняются во время выполнения, когда интерпретатор чувствует, что это необходимо. Если вы сравниваете целое число со строкой, это означает, что они должны быть одного типа, так, например, "34" == 34 истинно, так как целое число, вероятно, будет типизировано в строку перед сравнением.

строка "false" не типизируется в bool, вместо этого bool false типизируется в строку, которая будет иметь значение "0", то есть, строка, содержащая число 0, дающее " 0 "= = "false", которое, очевидно, является ложным.

Если вы хотите сравнить значение без автоматической типизации, эффективно сравнивая типы, а также значения, используйте тройное равенство:

5 === "5" ложные "string" = = = "string" true

1

почему это так?

потому что JavaScript и слабо типизирован, и дико непоследователен. Не все его конструктивные особенности хорошо продуманы; он был создан, реализован и развернут невероятно быстро по сравнению с любым другим языком программирования, в спешке, чтобы получить Netscape 2.0. Вскоре после этого он успокоился, потерял некоторых из наиболее вопиющих ошибок и стал полу-стандартизированным.

искать какой-то философский обоснование таких вещей, как неявные правила кастинга типов, скорее всего, будет бесплодным упражнением. Только действительно последовательное принципе на JavaScript придерживается составляет DWIM, очень в отрицательном смысле.

1

JavaScript определяет значения falsey равными 0, boolean false и undefined. Любая строка вне "0" будет истинной, даже если эта строка "false".

раздражает, правда.

0