> ## 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. # Bash Integer Less Than Or Equal The `-le` operator is a binary integer comparison operator in Bash that evaluates whether the left operand is mathematically less than or equal to the right operand. It returns an exit status of `0` (true) if the condition is met, and `1` (false) if the left operand is strictly greater than the right operand. ## Syntax The operator is utilized within the `test` command, the POSIX-compliant single bracket `[ ]`, or the Bash-specific extended test keyword `[[ ]]`. ```bash theme={"dark"} # POSIX-compliant test command test INT1 -le INT2 # POSIX-compliant single bracket [ INT1 -le INT2 ] # Bash extended test keyword [[ INT1 -le INT2 ]] ``` ## Technical Mechanics * **Operand Constraints:** The `-le` operator strictly requires integer evaluation; Bash does not natively support floating-point arithmetic. The behavior upon encountering invalid types depends on the context: * In `[ ]` and `test`: Operands must be strictly integer literals. Passing a floating-point number (e.g., `2.5`) or a non-numeric string results in a runtime error (`bash: [: : integer expression expected`) and yields an exit status of `2`. * In `[[ ]]`: Operands undergo arithmetic evaluation. Passing a standard non-numeric string (e.g., `"abc"`) does not inherently throw an error; instead, Bash treats the string as a variable name within an arithmetic context. If the variable is unset, it silently evaluates to `0`. A syntax error is only triggered if the string contains fundamentally invalid arithmetic syntax (e.g., `"a b"` or `2.5`), yielding an exit status of `1`. * **Empty Variable Handling:** * In the POSIX `[ ]` context, an unquoted empty variable results in a syntax error due to a missing expected argument. A quoted empty string (`""`) yields an `integer expression expected` error. * In the extended `[[ ]]` context, an unset variable referenced strictly by name (e.g., `[[ var -le 2 ]]`) implicitly evaluates to the integer `0`. Conversely, an empty string literal or an expanded empty variable (e.g., `[[ "" -le 2 ]]` or `[[ $var -le 2 ]]`) causes an arithmetic syntax error (`bash: [[: : syntax error: operand expected`). * **Base Representation:** * In `[ ]` and `test`: Operands are strictly parsed as base 10. A leading `0` does not trigger octal interpretation (e.g., `010` is evaluated as `10`), and hexadecimal prefixes (e.g., `0x10`) result in an `integer expression expected` error. * In `[[ ]]`: Because operands are subjected to arithmetic evaluation, standard Bash integer bases apply. A leading `0` is interpreted as octal, and a leading `0x` is interpreted as hexadecimal. ## Evaluation Differences vs. Arithmetic Expansion While `-le` serves the same logical purpose as the `<=` operator used within Bash's arithmetic expansion context `(( ))`, their evaluation mechanics differ significantly. ```bash theme={"dark"} [ "$a" -le "$b" ] (( a <= b )) ``` In the `[ ]` construct, `-le` strictly requires integer literals. If a variable contains an arithmetic expression (e.g., `a="1+1"`), `[ ]` will throw an error. In contrast, `(( ))` performs full arithmetic evaluation, successfully resolving `1+1` to `2` before the comparison. Furthermore, `(( ))` treats non-numeric strings as variable names or `0`, whereas `[ ]` throws an error. *Note: Do not confuse `-le` with the `<` or `>` operators inside `[[ ]]`. The `-le` operator performs mathematical integer comparisons, whereas `<` and `>` perform lexicographical (string) comparisons based on the current locale's collating sequence. Bash does not support a `<=` operator inside `[[ ]]`.*

Tired of Poor Bash Skills? Fix That With Deep Grasping! Learn More