Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

The !== operator is the strict inequality (or “not identical”) operator in PHP. It evaluates two operands and returns true if they are not equal in value or if they are not of the exact same data type. It returns false only when both operands share the identical type and value. Unlike the loose inequality operator (!=), the !== operator strictly bypasses PHP’s internal type juggling (type coercion). It will never attempt to cast operands to a common type before performing the comparison. 
$result = $expression1 !== $expression2;

​
Evaluation Mechanics

When the PHP engine executes a !== operation, it follows a strict two-step evaluation sequence:
  1. Type Comparison: PHP first inspects the internal data types (e.g., integer, string, boolean, null) of both operands. If the types differ, the engine immediately halts evaluation and returns true.
  2. Value Comparison: If, and only if, the data types are identical, PHP proceeds to compare the actual values. If the values differ, it returns true. If the values are exactly the same, it returns false.

​
Syntax Visualization

// 1. Type mismatch (returns true)
1 !== "1"         // true  (integer vs. string)
1 !== true        // true  (integer vs. boolean)
0 !== null        // true  (integer vs. null)
0 !== false       // true  (integer vs. boolean)

// 2. Type match, value mismatch (returns true)
10 !== 20         // true  (both integers)
"foo" !== "bar"   // true  (both strings)
"PHP" !== "php"   // true  (case-sensitive string comparison)

// 3. Type match, value match (returns false)
10 !== 10         // false (identical type and value)
"foo" !== "foo"   // false (identical type and value)

​
Complex Type Behavior

The strict inequality operator applies specific rules when evaluating compound types (objects and arrays). Objects When comparing objects, !== evaluates object identity, not just property equality. It returns false if and only if both operands reference the exact same instance in memory. Two distinct instances of the same class with identical properties will evaluate to true. 
$objA = new stdClass();
$objB = new stdClass();
$objC = $objA;

$objA !== $objB; // true  (different instances in memory)
$objA !== $objC; // false (references to the exact same instance)
Arrays For arrays, !== evaluates to false only if both arrays contain the exact same key-value pairs, in the exact same order, and the values are of the exact same strict types. Any deviation in order, keys, values, or types results in true. 
$arr1 = [1, 2, 3];
$arr2 = [1, 2, "3"];
$arr3 = [1, 3, 2];

$arr1 !== $arr2; // true (type mismatch on the third element: integer vs. string)
$arr1 !== $arr3; // true (order mismatch)
$arr1 !== [1, 2, 3]; // false (identical keys, values, types, and order)
Master PHP with Deep Grasping Methodology!Learn More