Comparison Operators in JavaScript

comparison operators in JavaScript

JavaScript, as one of the most popular programming languages, plays a crucial role in web development. To harness its full potential, understanding comparison operators is essential. In this comprehensive guide, we will explore JavaScript’s comparison operators, from the basics to best practices. Whether you’re a beginner or an experienced developer, you’ll find valuable insights here.

In programming and coding dynamic web pages comparisons between values of variables become essential.

JavaScript’s Comparison Operators

JavaScript has a range of comparison operators to enable any type of comparison between variables.

The comparison is made to decide over a particular action to be taken. To determine the logic between two variables, we make use of JavaScript’s logical operators.

Conditional operators are special operators which assign a value / variable based on the result of the condition.

With the comparison operators, it’s general comparison of equality or difference. We’ll illustrate the types of comparison and logical operators in the following tables.

Equality Operators

Standard Algebraic OperatorJavaScript operatorSample JavaScript ConditionMeaning of JavaScript Condition
===X == YX is equal to Y
!=X != YX is not equal to Y

Relational Operators

Standard Algebraic OperatorJavaScript operatorSample JavaScript ConditionMeaning of JavaScript Condition
>>X > YX is greater than Y
<<X < YX is less than Y
>=X >= YX is greater than or equal to Y
<=X <= YX is less than or Equal to Y

Logical Operators

Standard Algebraic OperatorJavaScript operatorSample JavaScript ConditionMeaning of JavaScript Condition
AND&&X < 12 && Y > 20X is less than 12 AND Y is greater than 20
OR||X > 15 || Y > 20Either X is greater than 15 OR Y is greater than 20
NOT!!(X < Y)It is not that X is less than Y

Conditional Operator Syntax

The syntax for the conditional operators is

variable_name = (condition)? value1:value2

If the ‘condition’ is true then, the ‘value1’ is assigned to variable_name otherwise, ‘value2’ is assigned.

Complex Comparisons

You can create complex conditions by combining comparison operators and logical operators such as && (logical AND) and || (logical OR).

Using Logical AND (&&)

let age = 25;
let hasLicense = true;

if (age >= 18 && hasLicense) {
  console.log("You can drive!");
} else {
  console.log("You can't drive.");

In this example, both conditions (age >= 18 and hasLicense) must be true for the message “You can drive!” to be displayed.

Using Logical OR (||)

let isWeekend = false;
let isHoliday = true;

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

Here, either isWeekend or isHoliday being true is enough to trigger the “It’s time to relax!” message.

Comparison Operator Example

The example below will give you deeper understanding about the working of these operators.

It uses four if statements to display a time-sensitive greeting on a welcome page. The script obtains local time from the user’s computer and converts it to a 12-hour clock format. The script wishes you “Good Morning” in the morning and “Good Evening” in the Evening.

<title> Using Relational And Logical Operators </title>
<script type=”text/javascript”>
Var time;
now=new Date(); // Date is a predefined function and new is used to create                                  //an instance of an object. i.e. it tells that now is refers to function //Date.                                  
hour= now.getHours();
if (hour<12)
document.write( “<h1>Good Morning!! </h1>”);
if (hour >=12)
if (hour<6 && hour>12) //&& logically compares truth of two values
document.write(“<h1>Good afternoon!!</h1>”);
document.write(“<h1>Good Evening!!<h1>”);

<body> <p> Click refresh to run the script again </p>

This ends the tutorial about the relational, logical and conditional operators in JavaScript.

Best Practices

When working with comparison operators in JavaScript, it is important to follow best practices to ensure that your code is robust and maintainable. Here are some best practices to consider:

1. Use Strict Equality

In JavaScript, the equality operator ( == ) and inequality operator ( != ) can lead to unexpected results due to type coercion. Type coercion is the process of converting a value from one data type to another, which can sometimes result in unexpected behavior.

To avoid this, it is recommended to use the strict equality ( === ) and strict inequality ( !== ) operators whenever possible. These operators compare values without performing type coercion, which can help ensure that the comparison is accurate and predictable.

For example, consider the following code:

console.log(5 == '5'); // true
console.log(5 === '5'); // false

In the first line, the equality operator is used to compare the number 5 with the string ‘5’. Since JavaScript performs type coercion in this case, the string ‘5’ is converted to a number before the comparison is made. This results in a true value being returned.

In the second line, the strict equality operator is used instead. Since this operator does not perform type coercion, the comparison returns false since the number 5 is not equal to the string ‘5’.

By using the strict equality and strict inequality operators, you can avoid unexpected type coercion and ensure that your code behaves predictably.

2. Be Explicit

When writing code, it is important to clearly state your intentions. This means making your code easy to understand and interpret by others, including your future self. One way to achieve this is by using comments to explain complex conditions and comparisons.

Comments are lines of code that are not executed by the program but serve as explanations or annotations for the code. They provide additional context and clarification for parts of the code that may be difficult to understand at first glance.

When dealing with complex conditions or comparisons, it is helpful to include comments that explain the logic behind them. This can make it easier for other programmers to follow the code and understand the reasoning behind specific decisions or calculations.

For example, if you have a complex if statement with multiple conditions, you can use comments to break down each condition and explain its purpose. This can help other programmers understand the logic flow and make it easier to debug or modify the code in the future.

It is also important to use meaningful variable and function names that accurately reflect their purpose. This can make the code more self-explanatory and reduce the need for excessive comments.

However, it is worth noting that while comments can be helpful, they should not be used as a substitute for writing clear and concise code. Strive to write code that is self-explanatory and easy to understand without relying heavily on comments.

3. Test Edge Cases

Testing code is an essential part of the software development process. It involves running the code with various inputs to ensure that it behaves as expected. This helps identify bugs and errors in the code, and ensures that the code is functioning correctly.

When testing code, it’s important to consider edge cases. An edge case is a scenario that is unlikely to occur, but still possible. For example, if you’re writing a program that calculates the average of a list of numbers, an edge case would be an empty list or a list with only one number.

By testing edge cases, you can ensure that your code is robust and able to handle unexpected scenarios. This can help prevent errors and bugs in the code, and make your code more reliable.

There are several types of tests that can be performed on code, including unit tests, integration tests, and acceptance tests. Each type of test serves a different purpose and can help ensure that your code is functioning correctly.

4. Consistency

Consistent coding conventions are a set of guidelines that programmers follow while writing code. Adhering to these conventions within a team or project can greatly improve code readability.

Code readability refers to how easy it is to understand and interpret the code. When code is written in a consistent manner, it becomes easier for other programmers to read and understand it. This can save time and effort, especially when working on large projects with multiple team members.

Some common coding conventions include naming conventions, indentation, commenting, and formatting. By following these conventions, the code becomes more organized and easier to navigate. Additionally, it can help prevent errors and bugs in the code.


Comparison operators are essential tools in JavaScript for making decisions and controlling program flow. Understanding their nuances, including type coercion, strict vs. loose equality, and common pitfalls, will help you write more reliable and maintainable code.

By following best practices and being mindful of the potential pitfalls, you can confidently use comparison operators in your JavaScript projects. Whether you’re comparing numbers, strings, or complex conditions, JavaScript’s comparison operators are your reliable companions on your coding journey.

For further reading and in-depth information, explore the official JavaScript documentation on comparison operators and practice your skills to become a proficient JavaScript developer.

Remember, mastering comparison operators is just one step on the path to JavaScript expertise, but it’s a crucial one. Happy coding!

Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
AS3 Button

AS3 Button Tutorial Coverage

Next Post

ActionScript 3: Crafting Web Marvels with HTML5 and JavaScript