TypeScript Loose Inequality

operand1 != operand2

​

Evaluation Mechanics

1. Identical Types: If both operands are of the same type, no coercion occurs. The operator behaves identically to !==.
2. NaN Behavior: The NaN (Not-a-Number) value is never equal to any value, including itself. Therefore, NaN != NaN always evaluates to true.
3. Nullish Operands: null and undefined are considered loosely equal to each other, but not to any other values. Therefore, null != undefined evaluates to false. Comparing any object to null or undefined evaluates to true without triggering any type conversion.
4. Primitive Coercion: If comparing a number and a string, the runtime attempts to convert the string to a number before evaluating inequality.
5. Boolean Coercion: If one operand is a boolean, it is converted to a number (true becomes 1, false becomes 0) before comparison.
6. Object to Primitive: If one operand is an object and the other is a string, number, bigint, or symbol, the object is converted to a primitive value via its valueOf() or toString() methods before comparison.

​

TypeScript Static Analysis Behavior

const str: string = "1";
const num: number = 1;

// TS2367: This condition will always return 'true' since the types 'string' and 'number' have no overlap.
const result = str != num; 

const looseString: any = "42";
const strictNumber: number = 42;

// Evaluates to false. "42" is coerced to 42, making them equal.
const isNotEqual = looseString != strictNumber; 

const nullVal: null = null;
const undefinedVal: undefined = undefined;

// Evaluates to false. Permitted by the compiler exception for nullish types.
const isNullishNotEqual = nullVal != undefinedVal; 

​

Memory Reference Comparison

const objA: any = { id: 1 };
const objB: any = { id: 1 };
const objC: any = objA;

console.log(objA != objB); // true (different memory references)
console.log(objA != objC); // false (same memory reference)