Logical Operators, Associativity and Precedence in PHP
PHP supports the basic if, if-else, and if-else-if conditional structures as well as switch statements. Logical statements are built using the standard logical operators for numeric comparisons as well as logical operators such as negations, And, and Or.
PHP has a built-in Boolean type and supports the keywords
false . However,
any variable can be treated as a Boolean if used in a logical expression. Depending on
the variable, it could evaluate to true or false! For example, an empty string,
or a numeric value of zero,
0 are all considered false. A non-empty string, a non-zero
numeric value, or a non-empty array all evaluate to true. It is best to avoid these issues
by writing clean code that uses clear, explicit statements.
Because PHP is dynamically typed, comparison operators work differently depending on
how they are used. First, let’s consider the four basic inequality operators,
>=. When used to compare numeric types to numeric types, these operators work
as expected and the value of the numbers are compared.
$a = 10; $b = 20; $c = 20; $r = ($a < $b); //true $r = ($a <= $b); //false $r = ($b <= $c); //true $r = ($a > $b); //false $r = ($a >= $b); //false $r = ($b >= $c); //true
When these operators are used to compare strings to strings, the strings are compared lexicographically according to the standard ASCII text table. Some examples follow, but it is better to use a function to do string comparisons.
$s = "aardvark"; $t = "zebra"; $r = ($s < $t); //true $r = ($s <= $t); //true $r = ($s >= $t); //false $r = ($s > $t); //false
However, when these operators are used to compare strings to numeric types, the strings
are converted to numbers using the same type juggling that happens when strings are
mixed with arithmetic operators. In the following example,
$b gets converted to a
numeric type when compared to
$a which give the results indicated in the comments.
$a = 10; $b = "10"; $r = ($a <= $b); //true $r = ($a < $b); //false $r = ($a >= $b); //true $r = ($a > $b); //false
With the equality operators,
!=, something similar happens. When the types of
the two operands match, the expected comparison is made: when numbers are compared
to numbers their values are compared; when strings are compared to strings, their content
is compared (case sensitively). However, when the types are different they are type
juggled and strings are converted to numbers for the purpose of comparison. Thus, a
comparison like (
10 == "10") ends up being true! The operators are
referred to as loose comparison operators because of this.
What if we want to ensure that we’re comparing apples to apples? To rectify this, PHP
offers another set of comparison operators, strict comparison operators,
(each has an extra equals sign). These operators will make a comparison without
type casting either operand first. Now a similar comparison, (
10 === "10") ends up
evaluating to false. The operator
=== will only evaluate to true if the both the operands’
$a = 10; $b = "10"; $r = ($a == $b); //true $r = ($a != $b); //false
$r = ($a === $b); //false $r = ($a !== $b); //true
The three basic logical operators, not
&&, and or
|| are also supported in PHP.
Order of Precedence
At this point it is worth summarizing the order of precedence of all the operators that we’ve seen so far including assignment, arithmetic, comparison, and logical. Since all of these operators could be used in one statement, for example:
($b*$b < 4*$a*$c || $a === 0 || $argc != 4)
it is important to understand the order in which each one gets evaluated. The table below summarizes the order of precedence for the operators seen so far. This is not an exhaustive list of PHP operators.