How to use ternary operator in JavaScript

One of the methods is the JavaScript ternary operator, a powerful tool that shortens conditional statements into a compact form.

In this article, we will discuss in detail the ternary operator JavaScript, exploring its syntax, use cases, and best practices.

How to Use JavaScript Ternary Operator?

The ternary operator in JavaScript offers a simple method to express conditional statements.

The syntax to used:

condition ? expression_if_true : expression_if_false;

Let’s discuss the components:

  • Condition
    • This is the expression that is classified as either true or false.
  • Expression if True
    • The code to perform if the condition calculates to true.
  • Expression if False
    • The code to perform if the condition calculates to false.

Using the Ternary Operator for Simple Conditions

When you have a truthful condition and simple expressions, the ternary operator shows.

Here’s an example code:

const price = 23;
const isHighest = price >= 23 ? "Yes" : "No";

Here, if the price is greater than or equal to 23, the isHighest variable will hold “Yes“, otherwise, it will hold “No“.

Handling Multiple Conditions

The ternary operator is not limited to just one condition. You can chain multiple ternary operators to handle different cases.

Furthermore, make sure that your code remains readable and does not become overly complex.

const weatherSample = "rainy";
const activitySample =
  weatherSample === "sunny"
    ? "Go for a walk in the straight"
    : weatherSample === "rainy"
    ? "Stay in House"
    : "Check the forecast weather";

Ternary Operator vs. If-Else

While the ternary operator integrates simple conditions, for more complicated situations, traditional if-else statements might be more compatible.

This maintains code readability and prevents nesting ternary operators extremely.

Using Ternary Operator with HTML

The ternary operator can also be useful when constantly changing HTML content.

Assume that you want to show a message based on a user’s subscription status.

const isSubscribedSample = true;
const subscriptionMessage = isSubscribedSample
  ? "<p>Welcome, valued subscriber!</p>"
  : "<p>Subscribe to access premium content.</p>";

Checking for Even or Odd

Assume that you need to define if a given number is even or odd and show a corresponding message.

Here’s how you can obtain this using the ternary operator:

const num = 10;
const resultSample = num % 2 === 0 ? "Even" : "Odd";
console.log(`The num is ${resultSample}.`);

In this example, if the condition number % 2 === 0 is true, the result will be “Even” otherwise, it will be “Odd“.

Handling Null Values

When managing with variables that might be null or undefined, the ternary operator can offer a clear solution.

Let’s see an example code:

const person = getUsernameFromDatabase();
const displayPerson = person ? person : "Guest";
console.log(`Welcome, ${displayPerson}!`);

In this example code, if “person has a value, it will be used as the “displayPerson“; otherwise, “Guest” will be used.

Nested Ternary Operators in JavaScript

While it is essential to keep code readable, sometimes nesting ternary operators can lead to more precise code.

However, you can use this method accordingly to prevent excessive complexity.

Here’s an example:

const grade = 95;
const average =
  grade >= 96
    ? "A"
    : grade >= 93
    ? "B"
    : grade >= 71
    ? "C"
    : grade >= 65
    ? "D"
    : "F";
console.log(`You got ${average} average.`);

In this example code, the nested ternary operators help define the grade based on the score.

Advantages of Using the Ternary Operator

It provides multiple advantages that make code more compact and readable, especially when used accordingly.

Here are the following advantages:

  • Conciseness
  • Readability
  • Reduced Nesting
  • Assignment within Expressions
  • Functional Programming
  • Expression Usage
  • Performance

Best Practices for Using Ternary Operator

While the ternary operator can improve code readability, it is important to use it properly.

Here are the following best practices:

  • Keep It Simple
    • Use the ternary operator for truthful conditions. For complicated conditions, stick to traditional if…else statements for simplicity.
  • Avoid Nesting
    • Avoid excessive nesting of ternary operators as it can result in disorientation. If nesting becomes necessary, assume for refactoring your code.
  • Maintain Readability
    • Give precedence to code readability; choose the if…else approach over the ternary operator if it enhances code clarity.
  • Parentheses
    • Use parentheses to simplify the order of operations, specifically when combining ternary operators with other expressions.
  • Comments
    • Include comments to explain the logic behind the ternary operator, specifically if the condition is not immediately accessible.


Can I use multiple ternary operators in a single line?

Yes, you can chain multiple ternary operators. However, be vigilant not to sacrifice readability.

What happens if I don’t provide an expression for the “false” condition?

If the “false” expression is deleted, the operator returns undefined when the condition is false.

Is the ternary operator faster than if-else statements?

Performance differences are usually unimportant. Prioritize code readability over micro-optimizations.


Mastering the ternary operator in JavaScript allows you to write more precise and effective code.

By understanding its syntax, best practices, and applications, you can improve your coding skills and create cleaner solutions.

Remember, while the ternary operator is a valuable tool, it is important to prioritize code readability and maintainability.

Additional Resources

Leave a Comment