JavaScript Equals: The Equality Operator in JS

The JavaScript equals or loose equality operator (==) checks if two variables or values are equal. It returns true if two values are of equal value, even if they’re of different types. Conversely, it returns false if the values aren’t of equal value.

How to Use the Equality Operator in JavaScript

The equals operator consists of two equals signs. Here’s the basic syntax for using the equality operator:

                  

                    jsx
                    
                      
                    
                  
                  

                    let a = '5';
let b = 5;

console.log(a == b); // Outputs: true because '5' becomes 5 before the comparison

                  
                

• ==: The symbol for the equality operator.
• a, b: The variables or values to compare.

When to Use the Equality Operator

The equality operator is useful for comparisons when types already match or you specifically want type conversion.

Conditional Logic

In web forms, where user inputs are strings, the loose equality operator can simplify comparisons with expected numeric values. Before comparing, the == operator performs type coercion to convert the string to a number.

                  

                    jsx
                    
                      
                    
                  
                  

                    let ageInput = document.querySelector('#age').value; // User inputs '30' as a string

if (ageInput == 30) {
    console.log('Thank you for confirming your age.');
}

                  
                

Filtering Data

When processing JSON data from APIs, == can filter or process elements where type conversion might be necessary:

                  

                    jsx
                    
                      
                    
                  
                  

                    fetch('https://api.example.com/products')
.then(response => response.json())
.then(products => {
    let filtered = products.filter(product => product.quantity == '10'); // Product quantity might come as a string
    console.log(filtered);
});

                  
                

Asserting Values in Unit Tests

During unit testing, you might use the equality operator to check outputs that are subject to type coercion:

                  

                    jsx
                    
                      
                    
                  
                  

                    let result = functionUnderTest('5', 5); // Function that returns 10 as a number or string based on input types

console.log(result == 10); // True if result is '10' or 10, useful for flexible testing scenarios

                  
                

Examples of Using the Equality Operator in JavaScript

E-Commerce Applications

As an example, consider special offers within an e-commerce website. You might use == to ensure that the number of items in the cart matches the offer requirements, even if the data types differ:

                  

                    jsx
                    
                      
                    
                  
                  

                    let itemsInCart = ['apple', 'banana', 'cherry']; // Items as an array of strings
let cartCount = document.querySelector('#cart-count').textContent; // Cart count from webpage as string

if (cartCount == itemsInCart.length) {
    console.log('Eligible for a discount!');
}

                  
                

Educational Software

In educational software, comparing student responses in different data formats to the correct answers stored in a system:

                  

                    jsx
                    
                      
                    
                  
                  

                    let correctAnswer = 4; // Correct answer as a number
let studentAnswer = document.querySelector('#answer').value; // Student's answer as a string from input field

if (studentAnswer == correctAnswer) {
    console.log('Answer is correct!');
}

                  
                

Learn More About the Equality Operator

JavaScript Not Equal Operator

The not equal operator (!=) checks if two values aren’t equal, converting types if necessary. Like the loose equality operator, != can treat seemingly different values as equal if they’re logically equivalent.

                  

                    jsx
                    
                      
                    
                  
                  

                    let accessLevel = '200';
if (accessLevel != 200) {
    console.log('Access level is not 200.');  // This will not execute because '200' is coerced to 200
} else {
    console.log('Access level is 200.');  // This will execute
}

                  
                

== vs. === in JavaScript

JavaScript features a loose equality operator (==) and a strict equality operator (===). The choice between double equals and triple equals as a comparison operator depends on your needs for type coercion.

== can be useful with forms, where any numerical values you capture are usually strings. In most cases, however, === is a better and safer choice to ensure type safety and avoid unintended behavior.

                  

                    jsx
                    
                      
                    
                  
                  

                    let quantity = 0;
let userInput = '0';

console.log(quantity == userInput); // Outputs: true
console.log(quantity === userInput); // Outputs: false, highlighting the importance of type safety