Знак не равно в программировании

Операторы == (равенство) и != (неравенство) проверяют равенство или неравенство своих операндов. The == (equality) and != (inequality) operators check if their operands are equal or not.

Оператор равенства == Equality operator ==

Оператор равенства == возвращает значение true , если его операнды равны. В противном случае возвращается значение false . The equality operator == returns true if its operands are equal, false otherwise.

Равенство типов значений Value types equality

Операнды встроенных типов значений равны, если равны их значения. Operands of the built-in value types are equal if their values are equal:

У операторов == , , > , и >= , если какой-то из операндов не является числом (Double.NaN или Single.NaN), результатом операции является false . For the == , , > , , and >= operators, if any of the operands is not a number (Double.NaN or Single.NaN), the result of operation is false . Это означает, что значение NaN не больше, не меньше и не равно любому другому значению double (или float ), включая NaN . That means that the NaN value is neither greater than, less than, nor equal to any other double (or float ) value, including NaN . Дополнительные сведения и примеры см. в справочных статьях по Double.NaN или Single.NaN. For more information and examples, see the Double.NaN or Single.NaN reference article.

Два операнда одного типа enum равны, если равны соответствующие значения базового целочисленного типа. Two operands of the same enum type are equal if the corresponding values of the underlying integral type are equal.

По умолчанию пользовательские типы struct не поддерживают оператор == . User-defined struct types don't support the == operator by default. Чтобы поддерживать оператор == , пользовательская структура должна перегружать его. To support the == operator, a user-defined struct must overload it.

Начиная с версии C# 7.3 операторы == и != поддерживаются кортежами C#. Beginning with C# 7.3, the == and != operators are supported by C# tuples. Дополнительные сведения см. в разделе Равенство и кортежи статьи Типы кортежей в C#. For more information, see the Equality and tuples section of the C# tuple types article.

Читайте также:  Задача no 317 число сочетаний

Равенство ссылочных типов Reference types equality

По умолчанию два операнда ссылочного типа являются равными, если они ссылаются на один и тот же объект: By default, two reference-type operands are equal if they refer to the same object:

Как показано в примере, определяемые пользователем ссылочные типы поддерживают оператор == по умолчанию. As the example shows, user-defined reference types support the == operator by default. Однако ссылочный тип может перегружать оператор == . However, a reference type can overload the == operator. Если ссылочный тип перегружает оператор == , воспользуйтесь методом Object.ReferenceEquals, чтобы проверить, что две ссылки этого типа указывают на один и тот же объект. If a reference type overloads the == operator, use the Object.ReferenceEquals method to check if two references of that type refer to the same object.

Равенство строк String equality

Два операнда string равны, если они оба имеют значение null или оба экземпляра строки имеют одинаковую длину и идентичные символы в каждой позиции символа. Two string operands are equal when both of them are null or both string instances are of the same length and have identical characters in each character position:

Это порядковое сравнение, учитывающее регистр. That is a case-sensitive ordinal comparison. Дополнительные сведения о том, как сравнивать строки, см. в статье Сравнение строк в C#. For more information about string comparison, see How to compare strings in C#.

Равенство делегатов Delegate equality

Два операнда delegate одного типа среды выполнения равны, если оба из них имеют значение null или их списки вызовов имеют одинаковую длину и содержат одинаковые записи в каждой позиции: Two delegate operands of the same runtime type are equal when both of them are null or their invocation lists are of the same length and have equal entries in each position:

Подробные сведения см. в разделе Delegate equality operators (Операторы равенства делегатов) в спецификации языка C#. For more information, see the Delegate equality operators section of the C# language specification.

Делегаты, созданные в результате оценки семантически идентичных лямбда-выражений не будут равны, как показано в примере ниже: Delegates that are produced from evaluation of semantically identical lambda expressions are not equal, as the following example shows:

Оператор неравенства != Inequality operator !=

Оператор неравенства != возвращает значение true , если его операнды не равны. В противном случае возвращается значение false . The inequality operator != returns true if its operands are not equal, false otherwise. Для операндов встроенных типов выражение x != y дает тот же результат, что и выражение !(x == y) . For the operands of the built-in types, the expression x != y produces the same result as the expression !(x == y) . Дополнительные сведения о равенстве типов см. в разделе Оператор равенства. For more information about type equality, see the Equality operator section.

Читайте также:  Как вернуть удаленный лист в экселе

В следующем примере иллюстрируется использование оператора != . The following example demonstrates the usage of the != operator:

Возможность перегрузки оператора Operator overloadability

Определяемый пользователем тип может перегружать операторы == и != . A user-defined type can overload the == and != operators. Если тип перегружает один из двух операторов, он должен также перегружать и другой. If a type overloads one of the two operators, it must also overload another one.

Состояние отпатрулирована

В математике повсеместно используются символы для упрощения и сокращения текста. Ниже приведён список наиболее часто встречающихся математических обозначений, соответствующие команды в TeX, объяснения и примеры использования. Список и смысл обозначений соответствует международным стандартам ISO 31−11 и ISO 80000−2.

Кроме указанных символов, иногда используются их зеркальные отражения, например, A ⊂ B <displaystyle Asubset B> обозначает то же, что и B ⊃ A . <displaystyle Bsupset A.>

Знаки операций, или математические символы — знаки, которые символизируют определённые математические действия со своими аргументами.

Многие операторы сравнения известны нам из математики:

  • Больше/меньше: a > b , a .
  • Больше/меньше или равно: a >= b , a .
  • Равно: a == b . Обратите внимание, для сравнения используется двойной знак равенства = . Один знак равенства a = b означал бы присваивание.
  • Не равно. В математике обозначается символом ≠ . В JavaScript записывается как знак равенства с предшествующим ему восклицательным знаком: a != b .

Результат сравнения имеет логический тип

Операторы сравнения, как и другие операторы, возвращают значение. Это значение имеет логический тип.

  • true — означает «да», «верно», «истина».
  • false — означает «нет», «неверно», «ложь».

Результат сравнения можно присвоить переменной, как и любое значение:

Сравнение строк

Чтобы определить, что одна строка больше другой, JavaScript использует «алфавитный» или «лексикографический» порядок.

Другими словами, строки сравниваются посимвольно.

Алгоритм сравнения двух строк довольно прост:

  1. Сначала сравниваются первые символы строк.
  2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй.
  3. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
  4. Сравнение продолжается, пока не закончится одна из строк.
  5. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.

В примерах выше сравнение 'Я' > 'А' завершится на первом шаге, тогда как строки «Кот» и «Код» будут сравниваться посимвольно:

  1. К равна К .
  2. о равна о .
  3. т больше чем д . На этом сравнение заканчивается. Первая строка больше.

Приведённый выше алгоритм сравнения похож на алгоритм, используемый в словарях и телефонных книгах, но между ними есть и различия.

Например, в JavaScript имеет значение регистр символов. Заглавная буква «A» не равна строчной «a» . Какая же из них больше? Строчная «a» . Почему? Потому что строчные буквы имеют больший код во внутренней таблице кодирования, которую использует JavaScript (Unicode). Мы ещё поговорим о внутреннем представлении строк и его влиянии в главе Строки.

Сравнение разных типов

При сравнении значений разных типов JavaScript приводит каждое из них к числу.

Логическое значение true становится 1 , а false — 0 .

Возможна следующая ситуация:

  • Два значения равны.
  • Одно из них true как логическое значение, другое — false .
Читайте также:  Для чего нужны винчестеры

С точки зрения JavaScript, результат ожидаем. Равенство преобразует значения, используя числовое преобразование, поэтому «0» становится 0 . В то время как явное преобразование с помощью Boolean использует другой набор правил.

Строгое сравнение

Использование обычного сравнения == может вызывать проблемы. Например, оно не отличает 0 от false :

Та же проблема с пустой строкой:

Это происходит из-за того, что операнды разных типов преобразуются оператором == к числу. В итоге, и пустая строка, и false становятся нулём.

Как же тогда отличать 0 от false ?

Оператор строгого равенства === проверяет равенство без приведения типов.

Другими словами, если a и b имеют разные типы, то проверка a === b немедленно возвращает false без попытки их преобразования.

Ещё есть оператор строгого неравенства !== , аналогичный != .

Оператор строгого равенства дольше писать, но он делает код более очевидным и оставляет меньше мест для ошибок.

Сравнение с null и undefined

Поведение null и undefined при сравнении с другими значениями — особое:

При строгом равенстве ===

Эти значения различны, так как различны их типы.

Эти значения равны друг другу и не равны никаким другим значениям. Это специальное правило языка.

Значения null/undefined преобразуются к числам: null становится 0 , а undefined — NaN .

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

Странный результат сравнения null и 0

Сравним null с нулём:

С точки зрения математики это странно. Результат последнего сравнения говорит о том, что « null больше или равно нулю», тогда результат одного из сравнений выше должен быть true , но они оба ложны.

Причина в том, что нестрогое равенство и сравнения > = работают по-разному. Сравнения преобразуют null в число, рассматривая его как 0 . Поэтому выражение (3) null >= 0 истинно, а null > 0 ложно.

С другой стороны, для нестрогого равенства == значений undefined и null действует особое правило: эти значения ни к чему не приводятся, они равны друг другу и не равны ничему другому. Поэтому (2) null == 0 ложно.

Несравнимое значение undefined

Значение undefined несравнимо с другими значениями:

Почему же сравнение undefined с нулём всегда ложно?

На это есть следующие причины:

  • Сравнения (1) и (2) возвращают false , потому что undefined преобразуется в NaN , а NaN — это специальное числовое значение, которое возвращает false при любых сравнениях.
  • Нестрогое равенство (3) возвращает false , потому что undefined равно только null и ничему больше.

Как избежать проблем

Зачем мы рассмотрели все эти примеры? Должны ли мы постоянно помнить обо всех этих особенностях? Не обязательно. Со временем все они станут вам знакомы, но можно избежать проблем, если следовать простому правилу.

Просто относитесь к любому сравнению с undefined/null , кроме строгого равенства === , с осторожностью.

Не используйте сравнения >= > с переменными, которые могут принимать значения null/undefined , если вы не уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.

Оцените статью
Adblock detector