> ## 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 Less Than Or Equal To
The `<=` (less than or equal to) operator is a relational comparison operator that evaluates two operands and returns a boolean `true` if the value of the left operand is mathematically, lexicographically, or structurally less than or equal to the value of the right operand. Otherwise, it returns `false`.
## Syntax
```php theme={"dark"}
$result = $expression1 <= $expression2;
```
## Evaluation Mechanics and Type Coercion
Because PHP is a dynamically typed language, the `<=` operator performs implicit type coercion (type juggling) when evaluating operands of differing data types. It is a non-strict operator, meaning it evaluates value equivalence rather than strict type identity.
The evaluation engine applies the following rules based on operand types:
1. **Numeric vs. Numeric:** Performs a standard mathematical comparison of integers or floats.
2. **String vs. String:** Performs a lexicographical comparison. The engine evaluates the strings byte-by-byte based on their ASCII values.
3. **Numeric String vs. Number:** If a string contains a valid numeric value, PHP casts the string to an integer or float before performing a mathematical comparison.
4. **Non-Numeric String vs. Number (PHP 8.0+):** The engine casts the number to a string and performs a lexicographical string comparison. *(Note: In PHP \< 8.0, the string was cast to `0` and compared mathematically).*
5. **Boolean vs. Other Types:** The non-boolean operand is cast to a boolean, and a boolean comparison is performed. In PHP, `false` is considered less than `true`.
6. **Array vs. Array:** Evaluates based on the number of elements first. An array with fewer elements is considered less than an array with more elements. If the element counts are equal, the engine performs an element-by-element comparison.
## Code Visualization
```php theme={"dark"}
// Standard numeric evaluation
var_dump(5 <= 10); // bool(true)
var_dump(10 <= 10); // bool(true)
var_dump(15 <= 10); // bool(false)
// Lexicographical string evaluation
var_dump("apple" <= "banana"); // bool(true)
var_dump("Z" <= "a"); // bool(true) (ASCII: 'Z' is 90, 'a' is 97)
// Type coercion: Numeric string and integer
var_dump("10" <= 10); // bool(true) (String "10" is cast to int 10)
var_dump(5 <= "10"); // bool(true)
// Type coercion: Boolean and integer
var_dump(false <= 0); // bool(true) (0 is cast to false, evaluates as false <= false)
var_dump(true <= 2); // bool(true) (2 is cast to true, evaluates as true <= true)
// PHP 8.0+ Mixed type evaluation (Number vs Non-numeric string)
var_dump(0 <= "foo"); // bool(true) (0 is cast to "0", lexicographically less than "foo")
// Array evaluation
var_dump([1, 2] <= [1, 2, 3]); // bool(true) (Left array has fewer elements)
var_dump([1, 2, 3] <= [1, 2, 3]); // bool(true) (Equal element count and values)
var_dump([1, 5, 3] <= [1, 2, 3]); // bool(false) (Equal count, element-by-element fails at 5 <= 2)
```
## Operator Precedence
The `<=` operator has lower precedence than arithmetic operators (e.g., `+`, `-`, `*`) and bitwise shift/NOT operators (`<<`, `>>`, `~`). However, it has **higher** precedence than bitwise AND, XOR, and OR operators (`&`, `^`, `|`), logical operators (e.g., `&&`, `||`), and assignment operators (`=`).
```php theme={"dark"}
// Arithmetic operations are evaluated before the <= comparison
$result = 5 + 5 <= 10 * 2;
// Evaluates as: (5 + 5) <= (10 * 2) -> 10 <= 20 -> true
// <= is evaluated before bitwise AND (&)
$result = 10 & 5 <= 5;
// Evaluates as: 10 & (5 <= 5) -> 10 & true -> 10 & 1 -> 0
```
Tired of Poor PHP Skills? Fix That With Deep Grasping!
Learn More
