Within a decision structure, does the order of terms change the outcome?

Question

Is there any difference between:

if (variavelA == variavelB)

and

if (variavelB == variavelA)

In Java and C#, is there a difference between the examples? I stress that the question is not limited to the operator only ==, but to all who can be used within decision-making frameworks.

Answer 1

The order can change the result in languages where there is operator overload.

Differences with overloaded operators

In C#, for example, you can create a specific implementation for the comparator == and several other operators. See a example:

public static DBBool operator ==(DBBool x, DBBool y) 
{
   if (x.value == 0 || y.value == 0) return dbNull;
   return x.value == y.value? dbTrue: dbFalse;
}

So variavelB and variavelA may be of different types and consequently the method overloaded == may have been in implemented differently in one or even in the two types.

Some languages that implement operator overload use them as simple method calls. In Ruby, for example, you can even call the operator as any method.

Consider the examples below. Both sum operations result in value 3:

a = 1 + 2 
b = 1.+(2)

The same goes for comparison:

if a == b
if a.==(b)

This might be different than:

if b == a
if b.==(a)

Obviously the above examples may differ if a and b are different classes.

No differences when it is not possible to extend the language

In languages such as Java or PHP, the order of comparison of variables is not important, because the operator == will always compare:

1. The values for primitive variables.
2. If they are objects, if they both point to the same instance.

Final considerations

The concepts presented here may vary subtly or abruptly from one language to another or even between versions of the language itself.

The important thing is that the developer understands the current mechanism that the language uses underneath the scenes.

Answer 2

I will give a partial response, aimed at . NET and Mono.

The behaviour of the operator == varies as follows:

• For reference types, it checks whether the references are equal, i.e.: if both objects are actually the same;
• For types by value, it will perform a proper equality implementation of the type. Every type by value has to have its own logic of equality. Try to define a struct, and then create two instances of that struct and try to see if they’re the same ==. Your code will not even compile ;) Note that in general the Framework’s native structs (bool, int, float etc.) have their own implementation for that operator.

Note that in both cases it is possible to overload the operator ==. In fact, it’s obligatory overload it in the second case if you are going to use it in your code.

If you overload the operator, then the logic of equality is completely yours. You know which operators are left and right, and you can do whatever you want with them. In this case, whether the order matters or not is a decision of the developer. If the operator is not overloaded, the order really makes no difference.

The same goes for comparison operators (>, <, >= and <=), if you refer to comparisons that must be equivalent, i.e.: a < b in relation to b > a. It depends only on the operators being overloaded, and the logic that was used in the overload. For comparable standard types in . NET and Mono (int, float and even DateTime), the comparison is strictly numerical, so for these types whatever.

Answer 3

For the operator "equal" (==) the order of conditions (variables, values, etc.) do not change the result.

Language-independent.

Answer 4

In Java it makes no difference.

I’ve done it several times using the equality operator == and the result is the same