Talal Zaman Abbasi - Software Engineer
CEO Bit Technologies - Best Digital Marketing Specialist in Pakistan
Talal Zaman Abbasi - Software Engineer
CEO Bit Technologies - Best Digital Marketing Specialist in Pakistan

Blog Post

How to Use Logic in JavaScript – Operators, Conditions, Truthy/Falsy, and More

November 29, 2023 Design
How to Use Logic in JavaScript – Operators, Conditions, Truthy/Falsy, and More


JavaScript is a versatile programming language that empowers developers to create dynamic and interactive web pages.

One of the foundational elements of JavaScript programming is the application of logical operations to make decisions and control program flow.

In this guide, we’ll delve into the basics of logical operations in JavaScript. I’ll provide simple explanations and ample code snippets to make these concepts easier to understand.

Understanding Logical Operators

Logical operators in JavaScript let developers perform operations on values or expressions, playing a crucial role in effective decision-making within code.

The primary logical operators are && (AND), || (OR), and ! (NOT). Let’s look at each one now.

1. AND (&&) Operator

The AND (&&) operator in JavaScript is a logical operator that combines two or more conditions. It returns true only if all the conditions being evaluated are true. If any of the conditions is false, the entire expression evaluates to false.


let isSunny = true;
let isWarm = true;

if (isSunny && isWarm) {
  console.log("Perfect weather for outdoor activities!");
} else {
  console.log("Maybe another day.");

In this example, the isSunny && isWarm condition must be true for the message about perfect weather to be displayed. If either isSunny or isWarm is false, the else block is executed.

Let’s look at some scenarios when the AND operator is particularly useful.

When combining conditions: Use && when you want an action to be taken only when multiple conditions are met simultaneously.

if (userIsLoggedIn && userHasPermission) {
  // Perform a privileged action.
} else {
  // Display an error message or redirect to login.

In guard clauses: Use && in guard clauses to ensure that certain conditions are met before proceeding with further code execution.

function performAction(user) {
  if (!user || !user.isLoggedIn) {
    return; // Exit early if the user is not logged in.

  // Continue with the action for logged-in users.

For form validation: In scenarios like form validation, you might use && to check multiple conditions before allowing form submission.

if (isUsernameValid && isPasswordValid && isEmailValid) {
  // Submit the form.
} else {
  // Display an error message.

The AND operator is useful when you want to ensure that all specified conditions are true before proceeding with a particular action or decision in your code. It’s a fundamental tool for creating more nuanced and context-specific logic in your JavaScript programs.

2. OR (||) Operator

The OR (||) operator in JavaScript is a logical operator that returns true if at least one of the conditions it connects is true. It is often used when you want an action to occur if any one of multiple conditions is met.

Here’s a basic example to illustrate the OR operator:

let hasCoffee = true;
let hasTea = false;

if (hasCoffee || hasTea) {
  console.log("You can enjoy a hot beverage!");
} else {
  console.log("No hot beverage available.");

In this example, the hasCoffee || hasTea condition is true because hasCoffee is true. As a result, the message “You can enjoy a hot beverage!” will be logged.

Here are some scenarios where you might want to use the OR operator:

Fallback Values:

let userInput = ""; // User didn't provide a value
let username = userInput || "Guest";
console.log("Welcome, " + username);

In this case, if the user didn’t provide a username (userInput is an empty string), the OR operator assigns a default value of “Guest” to username. This is a common pattern for providing fallback or default values.

Checking for Multiple Conditions:

let isWeekend = false;
let isHoliday = true;

if (isWeekend || isHoliday) {
  console.log("It's time for a break!");
} else {
  console.log("Back to work.");

This example uses the OR operator to check if it’s either the weekend or a holiday, indicating that it’s time for a break.

Form Validation:

let username = "john_doe";
let password = "";

if (username && password) {
  console.log("Form submitted successfully!");
} else {
  console.log("Please fill in both username and password.");

Here, the OR operator can be used to check if either the username or password is missing. If either condition is true, it prompts the user to fill in both fields.

The OR operator is useful when you want an action to occur if at least one of the specified conditions is true. It’s commonly employed in scenarios involving fallback values, checking multiple conditions, or form validation where any of several fields need to be filled.

3. NOT (!) Operator

The NOT (!) operator in JavaScript is a unary operator that negates the truthiness of a value. It’s used to invert a boolean value or a truthy/falsy expression. In simpler terms, it turns true into false and false into true. Here’s how it works:

let isSunny = true;

// Using NOT operator to invert the value
let isNotSunny = !isSunny;

console.log(isNotSunny); // Output: false

Now, let’s discuss when you might want to use the NOT operator:

Checking for Negation: The most straightforward use of the NOT operator is when you want to check for the negation of a condition. For example:

let isRaining = false;

if (!isRaining) {
  console.log("It's not raining. Enjoy the day!");
} else {
  console.log("Don't forget your umbrella!");

In this case, the !isRaining condition is true when it’s not raining. It provides a concise way of expressing the idea that it’s a good day when it’s not raining.

Checking for Falsy Values: The NOT operator is often used to check if a value is falsy. Remember that in JavaScript, certain values are considered falsy, such as false, 0, null, undefined, NaN, and an empty string "". The NOT operator can be handy for checking whether a variable holds a falsy value:

let userRole = null;

if (!userRole) {
  console.log("User role is not defined. Assigning a default role.");
  userRole = "Guest";

In this example, if userRole is null (a falsy value), the condition !userRole evaluates to true, and a default role is assigned.

Creating Clearer Conditions: The NOT operator can also be used to make conditions more explicit or readable. For instance:

let isLoggedIn = false;

if (!isLoggedIn) {
  console.log("User is not logged in. Redirect to login page.");

This condition checks if the user is not logged in and takes action accordingly.

The NOT operator is useful when you need to negate a boolean value or check for falsy values, providing a concise and readable way to express conditions in your JavaScript code.

How to Combine Logical Operators

You can combine logical operators to create more complex conditions, introducing parentheses to control the order of evaluation.  

Let’s consider an example where we want to determine if a person is eligible to enter a club based on their age and whether they have a valid ID. The conditions for entry are as follows:

  • The person must be at least 18 years old.
  • If the person is between 16 and 18 years old, they can enter only if they have a valid ID.
  • If the person is under 16, entry is not allowed.

Here’s the JavaScript code for this scenario:

let age = 17;
let hasValidID = false;

if ((age >= 18) || (age >= 16 && hasValidID)) {
    console.log("Welcome to the club!");
} else {
    console.log("Entry not allowed.");

In this code:

  • age is set to 17, indicating that the person is 17 years old.
  • hasValidID is set to false, indicating that the person does not have a valid ID.

Now, let’s evaluate the condition within the if statement:

  1. (age >= 18) evaluates to false because the person is not 18 or older.
  2. (age >= 16 && hasValidID) evaluates to true && false, which is false. This is because the person is 17, which satisfies the first part of the condition, but they don’t have a valid ID.

Since both parts of the condition are false, the code block inside the else statement is executed, resulting in the output:

Entry not allowed.

This example demonstrates how logical operators can be combined to create complex conditions, allowing you to control the flow of your program based on various factors.

Conditional Statements

Logical operators are frequently employed in conditional statements (if, else if, and else) to dictate program flow based on specific conditions.

1. if Statement:

The if statement in JavaScript is used to execute a block of code if a specified condition is true. Logical operators often play a crucial role in defining these conditions.

let isHungry = true;
let hasFood = true;

if (isHungry && hasFood) {
  console.log("Let's have a meal!");
} else {
  console.log("No need for a meal right now.");

In this example, the && (AND) operator combines two conditions (isHungry and hasFood). The block of code inside the if statement will execute only if both conditions are true. If either isHungry or hasFood is false, the code inside the else block will run.

2. else Statement:

The else statement is paired with the if statement to execute a block of code when the specified condition is false.

let isNight = true;

if (isNight) {
  console.log("It's nighttime. Sleep tight!");
} else {
  console.log("It's daytime. Enjoy your day!");

Here, the if statement checks if isNight is true. If it is, the corresponding message is printed. If isNight is false, the else block is executed, providing an alternative message for daytime.

3. else if Statement:

The else if statement accommodates multiple conditions, allowing for more complex decision-making.

let timeOfDay = "morning";

if (timeOfDay === "morning") {
  console.log("Good morning!");
} else if (timeOfDay === "afternoon") {
  console.log("Good afternoon!");
} else {
  console.log("Good evening!");

In this case, the code greets users differently based on the value of timeOfDay. The === operator is used for strict equality comparison, and logical operators like && or || can be incorporated to form more intricate conditions.

These examples illustrate how logical operators are employed within if, else, and else if statements to control the flow of a JavaScript program based on specific conditions.

Ternary Operator

The ternary operator, often denoted by ? :, provides a concise way to express conditional statements. It’s a shorthand version of an if-else statement. The basic syntax is:

condition ? expression_if_true : expression_if_false;

Here’s a breakdown of the components:

  • condition: a boolean expression that is evaluated. If it is true, the expression before the : is executed – otherwise, the expression after the : is executed.
  • expression_if_true: the value or expression returned if the condition is true.
  • expression_if_false: the value or expression returned if the condition is false.

Now, let’s take a closer look at the example provided:

const weather = isSunny ? "Enjoy the sunshine!" : "Grab an umbrella!";

In this example:

  • isSunny is the condition being checked. If isSunny is true, the value of the entire expression becomes “Enjoy the sunshine!”. If isSunny is false, the value becomes “Grab an umbrella!”.
  • The ? is like asking a question: “Is it sunny?” If the answer is yes, then “Enjoy the sunshine!” is the response (before the :). If the answer is no, then “Grab an umbrella!” is the response (after the :).

This can be seen as a shorthand way of writing an if-else statement. The equivalent if-else statement for the example would be:

let weather;
if (isSunny) {
  weather = "Enjoy the sunshine!";
} else {
  weather = "Grab an umbrella!";

Both the ternary operator and the if-else statement achieve the same result, but the ternary operator is more concise and is often used for simple conditional assignments.

It’s important to note that using the ternary operator excessively or in complex scenarios can reduce code readability, so it’s best used for straightforward conditions.

Switch Statement

The switch statement handles multiple conditions efficiently, particularly when there are several possible values for a variable. Extending our day-of-week example:

let dayOfWeek = "Wednesday";

switch (dayOfWeek) {
  case "Monday":
    console.log("It's the beginning of the week.");
  case "Wednesday":
    console.log("It's the middle of the week.");
  case "Friday":
    console.log("It's the end of the week.");
    console.log("It's an ordinary day.");

Here, the switch statement triggers the appropriate message based on the day of the week.

Short-Circuit Evaluation

JavaScript leverages short-circuit evaluation with logical operators, optimizing performance by halting evaluation once the result is determined.

Example 1: Short-Circuit with && Operator

let isTrue = false;
let result = isTrue && someFunction();

console.log(result); // `someFunction()` is not called if `isTrue` is false

In this example, someFunction() is only called if isTrue is true, showcasing the efficiency of short-circuit evaluation.

Example 2: Short-Circuit with || Operator

let isLoggedIn = false;
let username = isLoggedIn || "Guest";

console.log("Welcome, " + username); // If not logged in, the default username is "Guest"

Here, username is assigned the default value “Guest” only if the user is not logged in, thanks to short-circuit evaluation.

Truthy and Falsy Values

In JavaScript, logical operators can be used with non-boolean values. Understanding truthy and falsy values is crucial in such scenarios.

Truthy and Falsy Values Overview

Every value in JavaScript has inherent truthiness or falsiness. Falsy values include false, 0, null, undefined, NaN, and an empty string (""). Truthy values encompass all values not explicitly falsy.

Example: Truthy and Falsy Values

let userRole = ""; // An empty string is falsy

let roleMessage = userRole || "User";

console.log("You are a " + roleMessage); // If `userRole` is falsy, default to "User"

Here, the default value “User” is assigned to roleMessage only if userRole is falsy.

Summary Table

Let’s provide a quick reference for the different logical operators:

Operator Symbol Description
AND && Returns true if all conditions are true.
OR || Returns true if at least one condition is true.
NOT ! Inverts the result of a logical expression.

Practical Applications

Logical operators play a crucial role in real-world JavaScript applications. Here are some practical examples:

Form Validation

let username = "JohnDoe";
let password = "secretp@ss";

if (username && password) {
  console.log("Form submitted successfully.");
} else {
  console.log("Please enter both username and password.");

In this scenario, the form submission is validated by ensuring both the username and password are provided.

Responsive UI

let screenWidth = 800;

if (screenWidth > 600 && screenWidth <= 1024) {
  console.log("Displaying a tablet-friendly layout.");
} else if (screenWidth > 1024) {
  console.log("Displaying a desktop layout.");
} else {
  console.log("Displaying a mobile-friendly layout.");

Logical operators are often used to determine the layout based on the screen width, creating a responsive user interface.

Access Control

let userRole = "admin";
let isLoggedIn = true;

if (userRole === "admin" && isLoggedIn) {
  console.log("Access granted to admin dashboard.");
} else {
  console.log("Access denied.");

Logical operators help control access by verifying both the user role and login status.


Mastering logical operators is integral to writing effective and meaningful JavaScript code. Whether you’re creating conditions, making decisions, or controlling program flow, logical operators are essential tools.

By exploring these concepts through numerous examples, you’re well-equipped to apply them in your projects. Additionally, understanding truthy and falsy values enhances your ability to work with non-boolean contexts.

Use this guide as a foundation for writing clear and concise JavaScript, and you’ll be on your way to building robust and responsive web applications. Happy coding!


Source link