> ## 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.
# PHP Not Identical
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.
```php theme={"dark"}
$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
```php theme={"dark"}
// 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`.
```php theme={"dark"}
$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`.
```php theme={"dark"}
$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)
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
