Javascript Boolean Operators

• « Previous
• Next »

Boolean Operator NOT

The logical NOT operator is represented by an exclamation point ! and may be applied to any value in Javascript.

This operator always returns a Boolean value, regardless of the data type it's used on.

The logical NOT operator first converts the operand to a Boolean value and then negates it. The logical NOT behaves in the following ways:

• If the operand is an object, false is returned.
• If the operand is an empty string, true is returned.
• If the operand is a nonempty string, false is returned.
• If the operand is the number 0, true is returned.
• If the operand is any number other than 0 (including Infinity), false is returned.
• If the operand is null, true is returned.
• If the operand is NaN, true is returned.
• If the operand is undefined, true is returned.

console.log(!false);      //true
console.log(!"asdf");     //false
console.log(!0);          //true
console.log(!NaN);        //true
console.log(!"");         //true
console.log(!12);         //false

The code above generates the following result.

Boolean Operator NOT Example 2

The logical NOT operator can be used to convert a value into its Boolean equivalent.

By using two NOT operators, you can simulate the Boolean() casting function.

console.log(!!"asdf");     //true
console.log(!!0);          //false
console.log(!!NaN);        //false
console.log(!!"");         //false
console.log(!!12);         //true

The code above generates the following result.

Boolean Operator AND

The boolean operator AND operator is represented by the double ampersand << and is applied to two values:

Boolean operator AND behaves as described in the following truth table:

Boolean operator AND can be used with any type of operand, not just Boolean values.

When either operand is not a primitive Boolean, AND does not always return a Boolean value; instead, it does one of the following:

• If the first operand is an object, the second operand is returned.
• If the second operand is an object, the object is returned only if the first operand evaluates to true.
• If both operands are objects, then the second operand is returned.
• If either operand is null, then null is returned.
• If either operand is NaN, then NaN is returned.
• If either operand is undefined, then undefined is returned.

AND is a short-circuited operator: if the first operand determines the result, the second operand is not evaluated.

var found = true;
var result = (found && someUndeclaredVariable);    //error occurs here
console.log(result);    //this line never executes

found = false;
var result = (found && someUndeclaredVariable);    //no error
console.log(result);    //works

Boolean Operator OR

The Boolean Operator OR is represented by the double pipe || in Javascript, like this:

OR behaves as described in the following truth table:

If either operand is not a Boolean, logical OR will not always return a Boolean value; instead, it does one of the following:

• If the first operand is an object, then the first operand is returned.
• If the first operand evaluates to false, then the second operand is returned.
• If both operands are objects, then the first operand is returned.
• If both operands are null, then null is returned.
• If both operands are NaN, then NaN is returned.
• If both operands are undefined, then undefined is returned.

OR operator is short-circuited. In this case, if the first operand evaluates to true, the second operand is not evaluated.

var found = true;
var result = (found || someUndeclaredVariable);    //no error
console.log(result);    //works

found = false;
var result = (found || someUndeclaredVariable);    //error occurs here
console.log(result);    //this line never executes

Because the variable found is set to true, the variable someUndefinedVariable is never evaluated and thus the output is "true". If the value of found is changed to false, an error will occur.

To avoid assigning a null or undefined value to a variable, use the following code.

If preferredObject isn't null, then it's assigned to myObject; if it is null, then backupObject is assigned to myObject.

• Next »
• « Previous