Logical operators

Logical operators are used to perform boolean operations on values and variables. These operators are used in conditional structures and loops to combine multiple conditions and obtain a final result.

The most common logical operators are AND, OR, and NOT:

AND and OR operators

The AND and OR operations are basic logical operations, whose result is given by the following table.

• AND returns true if both operands are true, and false otherwise
• OR returns true if at least one of the operands is true

If you think about it for a moment, it’s the same sense we usually use for the word AND and OR, respectively, in everyday use.

For example, when you say

I’ll take the coat if it rains AND it’s cold

You take the coat only if both conditions are met at the same time.

While when you say,

I’ll take the coat if it rains OR it’s cold

You take the coat as long as one of the two conditions is met.

NOT operators

On the other hand, the NOT operator is very simple, and simply inverts a logical value.

Example in different languages

In languages with syntax inherited from C the operators are &&, ||, and !.

bool or_a_b = a || b;
bool and_a_b = a && b;
bool not_a_b = !a;

let or_a_b = a || b;
let and_a_b = a && b;
let not_a_b = !a;

or_a_b = a or b
and_a_b = a and b
not_a_b = not a

Short-circuited operators

In many languages, both AND and OR offer short-circuited versions. These operators are a mechanism to speed up the evaluation of expressions.

A short-circuit operator stops the evaluation as soon as it knows the result without needing to evaluate the rest of the operators

To do this, the “trick” is used that an operation with several AND will be false, with one of the members being false. Similarly, a series of conditions with OR will be true with one of its members being true.

We can use this to speed up the calculation of expressions, which is precisely what the short-circuited versions do.

• AND stops the evaluation as soon as it finds a false and evaluates the expression as false.
• OR stops the evaluation as soon as it finds a true, and evaluates the expression as true

That is,

For example, in this expression in C#,

// if (a > b) is true
// (c < d) will never be evaluated
bool result = (a > b) && (c < d);  

In general, we will almost always use the short-circuited versions of the operators, because they are more efficient.