What is not equal to in JavaScript

Learn how the not equal to operators work in JavaScript, including != and !==, their differences, type coercion pitfalls, and practical tips for reliable value comparisons.

JavaScripting Team

March 8, 2026·5 min read

JavaScript Tutorials Debugging Syntax Operators

Not equal to in JavaScript

Not equal to in JavaScript is a pair of inequality operators, != and !==, which compare two values and return true when they are not equal. They are used to test inequality in conditional logic and vary in how they handle type differences.

Understanding Not Equal To in JavaScript

Not equal to in JavaScript is a foundational concept you encounter when you write conditional logic, filter data, or validate user input. In practice, you test whether two values differ, and your code branches accordingly. According to JavaScripting, mastering inequality operators is essential for robust JavaScript code. JavaScript provides two operators for this purpose: !=, the loose not equal, and !==, the strict not equal. Both return booleans and are evaluated in conditions, but they handle types and objects in different ways. Grasping these nuances helps you write predictable and maintainable code, especially as your projects grow more complex.

When you see a statement like if (a != b) or if (a !== b), you are deciding whether to proceed based on whether the two sides do not represent the same value. The choice between loose and strict inequality often determines whether implicit type conversion should occur. A careful approach to these operators reduces bugs and makes intent clear to other developers who read your code.

The Operators: != and !==

The not equal operators come in two flavors, each designed for different scenarios:

!= loose not equal: performs type coercion before comparing values. This means a string containing a number can be treated as a number.
!== strict not equal: compares both value and type, without implicit conversion. This ensures only truly different values yield true.

Examples:

!= 9        // true
!= '10'     // false, '10' coerces to 10
!== 10       // false
!== '10'     // true, different types
!= false      // false, coerced to 0

Understanding these results helps you decide which operator to use in your conditions and data validation logic. When in doubt, prefer strict inequality to avoid surprises caused by coercion.

Type Coercion: Loose vs Strict

Type coercion is JavaScript automatically converting values from one type to another during comparison. The != operator applies coercion, so '2' and 2 can be treated as equal in some cases, while !== performs no coercion. This distinction is the core reason developers favor !== for most comparisons. Types involved include numbers, strings, booleans, null, and undefined, and even objects in some contexts. It is important to know when coercion is happening to avoid hidden bugs in complex expressions.

Primitives in Action: Numbers and Strings

Primitives behave predictably with strict inequality, but coercion can bite you with loose inequality. For numbers and numeric strings, you’ll often see:

10 != '10'     // false, '10' coerces to 10
10 !== '10'    // true, different types
'0' != 0        // false, '0' coerces to 0
'0' !== 0       // true, different types

Be mindful: for legitimate type-sensitive checks, choose !==; for broad checks that ignore type, != may be deliberate.

Objects and Arrays: Reference Equality

Not equal comparisons do not automatically compare the contents of objects or arrays. When you compare objects, the comparison is based on reference identity. Two separate objects with identical structure are not equal.

const a = { x: 1 };
const b = { x: 1 };
a != b        // true
a !== b       // true
const c = a;
c == a       // true

Note that for objects, even if they look the same, they are often different references.

Common Pitfalls and How to Avoid Them

Be aware of common mistakes:

Relying on != to handle both null and undefined. In many cases you should use value != null to test for both.
Assuming NaN equals itself. NaN is not equal to anything, including itself. Use Number.isNaN to test for NaN.
Mixing == and != inconsistently in a codebase can confuse readers and lead to bug-prone logic.

Understanding these pitfalls helps you write clearer and more reliable code.

Best Practices: When Not Equal Makes Sense

Practical guidelines:

Prefer !== for conditionals to avoid hidden coercion.
Use value != null to check for both null and undefined in one expression.
Avoid comparing complex types like objects with not equal; compare specific properties or use a utility function.
Document your reasoning when you intentionally rely on coercion with !=.

Following these practices leads to code that is easier to reason about and less error-prone in production.

Real World Examples: Validation and Filtering

Validation and filtering patterns:

// Example 1: Validate user age as a number and not undefined
function isValidAge(age) {
  return age !== undefined && age !== null && Number.isFinite(age);
}

// Example 2: Filter out empty strings
const list = ['a', '', 'b', null, undefined];
const nonEmpty = list.filter(v => v !== '');

In real apps you’ll often see not equal checks used to guard against missing values, trim inputs, or filter datasets before processing. Use clear intent and consider combining with other checks for robustness.

Debugging Not Equal Issues

When debugging not equal issues, start by isolating the comparison in a small snippet. Print the values and their types with typeof and, for objects, inspect references. Prefer strict not equal during development to catch type-related bugs early, and add explicit type checks when coercion is intentional. Document any unusual decisions to help future maintainers.

Questions & Answers

What is the difference between != and !== in JavaScript?

The != operator uses type coercion to compare values, while the !== operator checks both value and type without coercion. In practice, !== is safer in conditionals because it avoids surprising results caused by implicit conversions.

Should I ever use == or != in production code?

Typically, avoid == and != due to automatic type coercion. If you do use them, ensure you understand how coercion behaves in your specific cases and document the reasoning clearly.

How does type coercion affect not equal comparisons?

With !=, JavaScript may convert types before comparing, leading to results that seem surprising if you expect strict type checks. With !==, no coercion occurs, so type differences produce true for not equal.

What happens when comparing null and undefined with not equal?

Using !=, null and undefined are treated as equal, so null != undefined is false. Using !==, they are different types, so null !== undefined is true.

Do objects or arrays compare by value or reference in not equal?

Objects and arrays compare by reference, not by their contents. Two objects with the same properties are not equal unless they reference the same object.

Is NaN equal to itself in not equal comparisons?

NaN is not equal to any value, including itself. Therefore NaN != NaN and NaN !== NaN both evaluate to true. Use Number.isNaN to test for NaN explicitly.