В инструкции If Когда я должен использовать операторы =, ==. Есть ли оператор ===? В чем разница между этими операторами?
Использование равных операторов в С#
Ответ 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
Ответ 8
Для получения дополнительной информации оператор Not Equal !=.
Дополнительная информация о операторах С#: http://msdn.microsoft.com/en-us/library/6a71f45d%28v=VS.100%29.aspx
Ответ 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), и выдаст ошибку или исключение, когда он достигнет этого куска кода.