### 5.7 Logical Operators

The logical operators are typically used to perform Boolean algebra. They are often used in conjunction with comparison operators to express complex comparisons that involve more than one variable and are frequently used with the if, while, and for statements.

#### 5.7.1 Logical AND (&&)

When used with boolean operands, the && operator performs the Boolean AND operation on the two values: it returns true if and only if both its first operand and its second operand are true. If one or both of these operands is false, it returns false.

The actual behavior of this operator is somewhat more complicated. It starts by evaluating its first operand, the expression on its left. If the value of this expression can be converted to false (for example, if the left operand evaluates to null, 0, "", or undefined), the operator returns the value of the lefthand expression. Otherwise, it evaluates its second operand, the expression on its right, and returns the value of that expression.[1]

[1] In JavaScript 1.0 and JavaScript 1.1, if the lefthand expression evaluates to false, the && operator returns false, rather than returning the unconverted value of the lefthand expression.

Note that, depending on the value of the lefthand expression, this operator may or may not evaluate the righthand expression. You may occasionally see code that purposely exploits this feature of the && operator. For example, the following two lines of JavaScript code have equivalent effects:

```if (a == b) stop(  );

(a == b) && stop(  ); ```

While some programmers (particularly Perl programmers) find this a natural and useful programming idiom, I recommend against using it. The fact that the righthand side is not guaranteed to be evaluated is a frequent source of bugs. Consider the following code, for example:

`if ((a == null) && (b++ > 10)) stop(  ); `

This statement probably does not do what the programmer intended, since the increment operator on the righthand side is not evaluated whenever the comparison on the lefthand side is false. To avoid this problem, do not use expressions with side effects (assignments, increments, decrements, and function calls) on the righthand side of && unless you are quite sure you know exactly what you are doing.

Despite the fairly confusing way that this operator actually works, it is easiest, and perfectly safe, to think of it as merely a Boolean algebra operator. Although it does not actually return a boolean value, the value it returns can always be converted to a boolean value.

#### 5.7.2 Logical OR (||)

When used with boolean operands, the || operator performs the Boolean OR operation on the two values: it returns true if either the first operand or the second operand is true, or if both are true. If both operands are false, it returns false.

Although the || operator is most often used simply as a Boolean OR operator, it, like the && operator, has more complex behavior. It starts by evaluating its first operand, the expression on its left. If the value of this expression can be converted to true, it returns the value of the lefthand expression. Otherwise, it evaluates its second operand, the expression on its right, and returns the value of that expression.[2]

[2] In JavaScript 1.0 and JavaScript 1.1, if the lefthand expression could be converted to true, the operator returns true rather than returning the unconverted value of the lefthand expression.

As with the && operator, you should avoid righthand operands that include side effects, unless you purposely want to make use of the fact that the righthand expression may not be evaluated.

Even when the || operator is used with operands that are not boolean values, it can still be considered a Boolean OR operator, since its return value, whatever the type, can be converted to a boolean value.

#### 5.7.3 Logical NOT (!)

The ! operator is a unary operator; it is placed before a single operand. Its purpose is to invert the boolean value of its operand. For example, if the variable a has the value true (or is a value that converts to true), !a has the value false. And if the expression p && q evaluates to false (or to a value that converts to false), !(p && q) evaluates to true. Note that you can convert any value x to a boolean value by applying this operator twice: !!x.