JAvascript

Logical operators in JavaScript

Logical operators in JavaScript

JavaScript has three logical operators:

  • || which represents logical "OR"
  • && which represents logical "AND"
  • ! which represents logical "NOT".

|| (OR)

The "OR" logical operator returns true if either operand1 OR operand2 is true.

Syntax:

operant1 || operant2

For example:

alert( true || true );   // true
alert( false || true );  // true
alert( true || false );  // true
alert( false || false ); // false

From the table above we can construct the truth table of the "OR" logic operator.

operant1operant2result
truetruetrue
falsetruetrue
truefalsetrue
falsefalsefalse

Generally, the logical "OR" is supposed to deal with boolean operands only. However, in JavaScript, any operand that is not boolean is first converted to boolean before the evaluation.

This means that a number like 1 is treated as true and a number like 0 as false. For example:

console.log( 1 || 1 );   // 1
console.log( 0 || 1 );   // 1
console.log( 1 || 0 );   // 1
console.log( 0 || 0 );   // 0

In actual fact, it is only 0 that is treated as false, all the other numbers are treated as true.

console.log( 2 || 2 );   // 2
console.log( 0 || 2 );   // 2
console.log( 2 || 0 );   // 2
console.log( 0 || 0 );   // 0

The logical "OR" can be used to test if any one of the given conditions of an if statement is true. For example:

let hourOfDay = 5;
let lightIntensity = 0;

if (hourOfDay > 6 || lightIntensity < 0.5) {

  console.log( 'Switch on the Lights' ); // Switch on the Lights
}

The example above is a simulation of an automatic light switch using JavaScript. If the hour of the day is after 6 or if the light intensity is less than 50% it will log a message ("Swicth on the lights") to console. Only one of the conditions has to be true.

We can have as many conditions as we want:

value1 || value2 || value3 || value4

No matter how many values we have, the "OR" logical operator requires at least only one of the operands to be true and here is how it works:

  • the operands are evaluated from left to right.
  • if any operand is true, the logic stops there and returns the value of that operand.
  • If all operands are false the last operand is returned.
// returns the fist true value
console.log( 0 || 2 || 1 ); // 2
console.log( 0 || 1 || 2 ); // 1

// if no operant is true, it returns the last false value
console.log( null || undefined || 0 ); // 0
console.log( 0 || null || undefined ); // undefined
console.log( 0 || undefined || null ); // null

A value is returned in the original form of the operand, without the conversion.

Every non-empty string is considered true. This means that while 0 is false, "0" is true because its a non-empty string.

// numerical 0 is false and string 0 is true
console.log(Boolean(0) ); // false
console.log(Boolean("0")); // true
// returns the first true value in its original form
console.log( 0 || 1 ); // 1
console.log( "0" || 1 ); // 0

&& (AND)

The "AND" logical operator returns true if operand1 AND operand2 are both true.

Syntax

operand1 && operand2;

In classical programming AND returns true if both operands are truthy and false otherwise:

alert( true && true );   // true
alert( false && true );  // false
alert( true && false );  // false
alert( false && false ); // false

Its truth table:

operant1operant2result
truetruetrue
falsetruefalse
truefalsefalse
falsefalsefalse

For numerical values 1 is true and 0 is false.

console.log( 1 && 1 );   // 1
console.log( 0 && 1 );   // 0
console.log( 1 && 0 );   // 0
console.log( 0 && 0 );   // 0

No matter how many values we have, the "AND" logical operator requires all of the operands to be true and here is how it works:

  • the operands are evaluated from left to right.
  • if all operands are true, the logic returns the value of the last operand.
  • If any of the operands is false the first false operand is returned.
// returns the last true value
console.log( 1 && 2 && 3 ); // 3
console.log( 2 && 3 && 2 ); // 2

// if any operand is false, it returns the first false value
console.log( null && undefined && 0 ); // null
console.log( 0 && null && undefined ); // 0
console.log( 0 && undefined && null ); // 0
console.log( 1 && undefined && 0 ); // undefined
console.log( 1 && null && undefined ); // null
console.log( 1 && undefined && null ); // undefined

! (NOT)

The "NOT" logical operator returns true if the operand is not true.

Syntax:

!operand

Example:

// returns the inverse of the boolean value of the operand
console.log( !true ); // false
console.log( !0 ); // true
console.log( !1 ); // false
console.log( !"0" ); // false
console.log( !false ); // true
console.log( !23 ); // false