> ## 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 Division Assignment
The `/=` (division assignment) operator is a compound assignment operator that divides the variable on the left side by the expression on the right side, subsequently assigning the resulting quotient back to the left-side variable.
## Syntax
```php theme={"dark"}
$a /= $b;
```
This operation is semantically equivalent to the expanded assignment:
```php theme={"dark"}
$a = $a / $b;
```
## Type Evaluation and Mutation
Unlike operators that strictly preserve types, the `/=` operator dynamically mutates the data type of the left operand based on the mathematical result of the division:
1. **Integer Resolution:** If both operands evaluate to integers and the division produces no remainder (evenly divisible), the resulting assigned type remains an `int`.
2. **Float Resolution:** If either operand is a `float`, or if the division of two integers produces a remainder, the left operand is implicitly cast to a `float`.
```php theme={"dark"}
$x = 20;
$x /= 5;
var_dump($x); // int(4)
$y = 10;
$y /= 4;
var_dump($y); // float(2.5)
$z = 5.0;
$z /= 1;
var_dump($z); // float(5)
```
## Operator Precedence and Associativity
The `/=` operator has right-to-left associativity and shares the same low precedence as other assignment operators (like `=`, `+=`, `*=`). This means the entire expression on the right side is evaluated before the division and assignment occur.
```php theme={"dark"}
$a = 100;
$a /= 2 + 3;
// Evaluates as $a = 100 / (2 + 3), NOT ($a / 2) + 3
// $a becomes int(20)
```
## Error Handling and Edge Cases
* **Division by Zero:** In PHP 8.0 and later, executing `$a /= 0` throws a `DivisionByZeroError` exception. In PHP 7.x, division by zero emitted an `E_WARNING` and evaluated to a float (`INF`, `-INF`, or `NAN`). In PHP 5.x and older, it emitted an `E_WARNING` and evaluated to `bool(false)`.
* **Type Coercion:** If the right operand is a numeric string (e.g., `"2"`), PHP will implicitly coerce it to an `int` or `float` before performing the division.
* **Invalid Operands:** Passing a non-numeric string or other incompatible type to an arithmetic operator in PHP 8.0+ will always throw a `TypeError`. The `declare(strict_types=1)` directive has absolutely no effect on operator behavior, as it strictly applies only to function and method argument/return type declarations.
* **Uninitialized Variables:** If the left operand is undefined prior to the operation, PHP 8.0+ will emit an `E_WARNING` (Undefined variable), whereas PHP 7.x and older emitted an `E_NOTICE`. The engine treats the initial uninitialized value as `0`, and then performs the division. The result evaluates to `int(0)` or `float(0)` depending on the data type of the right operand.
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
