Подтвердить что ты не робот

Использование равных операторов в С#

В инструкции If Когда я должен использовать операторы =, ==. Есть ли оператор ===? В чем разница между этими операторами?

4b9b3361

ОТВЕТЫ

Ответ 1

= - это назначение, как в

var i = 5;

Не используйте этот оператор в инструкции if.

== для сравнения как в

if(i == 6){...}

в С#

нет оператора ===

Ответ 2

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

В С# == (как и все операторы в С#) является не полиморфным. То есть, "версия" ==, которая вызывается, всегда основана на статическом типе во время компиляции.

Например:

object a = Guid.NewGuid();
object b = new Guid(""+a);
a == b // false -- uses object.== -- an *identity* compare

С другой стороны, виртуальный метод Equals определен в object и, таким образом, является полиморфным для всех подтипов.

object a = Guid.NewGuid();
object b = new Guid(""+a);
a.Equals(b) // true -- uses Guid.Equals

Выбор того, какой из них использовать (== или Equals), иногда является тонким, но важным. Большинство типов коллекций будут использовать Equals для таких задач, как Contains и т.д. (Это довольно востребовано для всех общих контейнеров, поскольку для произвольного типа T нет T.==.)

// compile-time error: Operator '==' cannot be applied to operands of type 'T' and 'T'
bool equals<T> (T a, T b) { return a == b; }

// fair-game, because object defines Equals and it polymorphic to subtypes
bool equals<T> (T a, T b) { return a.Equals(b); }

См. Когда следует использовать == и когда следует использовать Equals? и Рекомендации по внедрению равных и оператора равенства (==) и т.д. Лично я использую == над Equals для статически разрешимых конкретных типов, для которых == является корректным, и я буду не (по контракту или соглашению) относятся к подтипу - примеры - это string и (большинство) типов структуры (например, int, Guid).

Счастливое кодирование.

Изменить: Нет оператора С# === (как говорили люди, duh!). Если говорить о варианте JavaScript, это будет примерно:

bool trippleEquals (object a, object b) {
  return a.GetType() == b.GetType() && a.Equals(b);
}

(Это строгое равенство в JavaScript, но не идентичность объекта).

Если говорить об идентичности объекта, то он должен быть таким же, как (object)a == (object)b, который имеет ту же семантику, что и object.ReferenceEquals(a,b).

Ответ 3

a single = для присваивания типа:

String myString = "Hi There";

Двойное равенство для сравнения

if (5 == 5)
{
    do something
}

тройной эквивалент в некоторых языках означает ровно равный.

С# не использует этот оператор.

Ответ 4

В дополнение к другим ответам ReferenceEquals(x,y), вероятно, ближе всего к ===.

Ответ 5

В выражении if вы обычно проверяете равенство, используя ==, оператор = - это оператор assignemt, и, насколько мне известно, в С# нет ===. Я никогда не слышал об этом, но он существует на других языках, я думаю в javascript он делает.

Ответ 6

Один знак равенства используется только для присвоения переменной значения, присваивание также возвращает одно и то же значение, поэтому я мог бы использоваться в операторе if, но никогда не должен (почти...) использоваться в выражении if. Двойные знаки равенства используются для проверки того, являются ли два значения равными и что вы используете большую часть времени. Я не знаю оператора ===.

/Виктор

Ответ 7

= является оператором присваивания , а == является оператором сравнения

Пример:

int a=2;
int b=3;    
int c=a=b; // a, b, c is equal to 3 as b=3

а

int a=2;
int b=3;

bool c= a==b // c = false since result of a==b is false

Ответ 9

Я встретил === только в javascript. Это строгий равный оператор. Я использовал его несколько раз, как это if(obj === undefined){ alert("obj has sublimed");}

Ответ 10

Это длинный комментарий, поэтому я решил добавить еще одно сообщение.

Я устанавливаю переменные var в список объектов и выполняю сравнение на двух варах, которые всегда не выполняли логику сравнения:

   object Object1;
   object Object2;  
   var v1 = Object1;
   var v2 = Object2;
   if (v1 != v2)
   {
     // Do something
   }

Благодаря сообщениям здесь, в этой теме, я изменил логику следующим образом, и теперь она отлично работает:

   object Object1;
   object Object2;  
   var v1 = Object1;
   var v2 = Object2;
   if (!v1.Equals(v2))
   {
     // Do something
   }

Ответ 11

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

"=" является оператором присваивания. Это используется для присвоения значения (или значений) переменной или объекту. Примером этого может быть:

int abc;
abc = 5;
Console.WriteLine("Print: " + abc);
*Console Output* Print: 5

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

"==" является оператором сравнения. Это способ сравнения значений в операторе if. Примером может быть:

int abc = 5;
int xyz = 10; //Notice the use of a single equal sign to assign the values
if (abc == xyz)
{
    Console.WriteLine("The values are equal");
}
else
{
    Console.WriteLine("The values are not equal");
}
*Console Output* The values are not equal

"===" технически будет называться идентичным оператором сравнения. Как указывалось в других ответах, С# не позволяет проводить подобные сравнения. Причина этого не в том, что один и тот же оператор сравнения проверяет, равны ли два типа объекта и их значение. По сути, он проверил бы:

double abc = 5;
int xyz = 5;
if (abc === xyz)
{
    Console.WriteLine("The values and variable types are equal");
}
*Console Output* Error

Причина, по которой вы не можете использовать оператор "===", заключается в том, что С# достаточно умен, чтобы знать перед сборкой, что две переменные не имеют одинаковый тип, и if операторы требуют, чтобы вы сравнивали одинаковые типы переменных. Если вы хотите сравнить int и double, вам нужно будет привести (или проанализировать) одну из переменных к тому же типу, что и другая. После приведения вы можете сравнить с обычным оператором "==".

Есть много языков, которые позволяют сравнивать с одинаковыми операторами сравнения. JavaScript является отличным примером языка, который допускает это. Поскольку в JavaScript может быть объявлено так много переменных как тип "var", полезно проверить, равно ли десятичное значение целочисленному значению. Однако С# увидит, что типы сравниваются некорректно во время сборки или даже во время кодирования (в зависимости от вашей IDE), и выдаст ошибку или исключение, когда он достигнет этого куска кода.