What is the difference between == and === operators?

JavaScript provides two types of equality operators:

• Loose equality (==, !=): Performs type conversion if the types differ, comparing values after converting them to a common type.
• Strict equality (===, !==): Compares both value and type, without any type conversion.

#### Strict Equality (===)

• Two strings are strictly equal if they have exactly the same sequence of characters and length.
• Two numbers are strictly equal if they have the same numeric value.
• Special cases:
• NaN === NaN is false
• +0 === -0 is true
• Two booleans are strictly equal if both are true or both are false.
• Two objects are strictly equal if they refer to the same object in memory.
• null and undefined are not strictly equal.

#### Loose Equality (==)

• Converts operands to the same type before making the comparison.
• null == undefined is true.
• "1" == 1 is true because the string is converted to a number.
• 0 == false is true because false is converted to 0.

#### Examples:

    0 == false            // true      (loose equality, type coercion)
    0 === false           // false     (strict equality, different types)
    1 == "1"              // true      (string converted to number)
    1 === "1"             // false     (different types)
    null == undefined     // true      (special case)
    null === undefined    // false     (different types)
    '0' == false          // true      ('0' is converted to 0)
    '0' === false         // false     (different types)
    NaN == NaN            // false     (NaN is never equal to itself)
    NaN === NaN           // false
    [] == []              // false     (different array objects)
    [] === []             // false
    {} == {}              // false     (different object references)
    {} === {}             // false