PHP offers a lot of powerful operators that range from arithmetic, string, and logical operators to assignment, comparison, and more (see Table 4-1).
Manipulate bits within bytes
Compare two values
Executes contents of backticks
Add or subtract 1
Each operator takes a different number of operands:
If all operators had the same precedence, they would be processed in the order in which they are encountered. In fact, many operators do have the same precedence, so let’s look at a few in Example 4-5.
Here you will see that although the numbers (and their preceding operators) have been moved, the result of each expression is the value 7, because the plus and minus operators have the same precedence. We can try the same thing with multiplication and division (see Example 4-6).
1 * 2 * 3 / 4 * 5 2 / 4 * 5 * 3 * 1 5 * 2 / 4 * 1 * 3
Here the resulting value is always 7.5. But things change when we mix operators with different precedences in an expression, as in Example 4-7.
1 + 2 * 3 - 4 * 5 2 - 4 * 5 * 3 + 1 5 + 2 - 4 + 1 * 3
If there were no operator precedence, these three expressions would evaluate to 25, −29, and 12, respectively. But because multiplication and division take precedence over addition and subtraction, there are implied parentheses around these parts of the expressions, which would look like Example 4-8 if they were visible.
1 + (2 * 3) - (4 * 5) 2 - (4 * 5 * 3) + 1 5 + 2 - 4 + (1 * 3)
Clearly, PHP must evaluate the subexpressions within parentheses first to derive the semicompleted expressions in Example 4-9.
1 + (6) - (20) 2 - (60) + 1 5 + 2 - 4 + (3)
The final results of these expressions are −13, −57, and 6, respectively (quite different from the results of 25, −29, and 12 that we would have seen had there been no operator precedence).
Of course, you can override the default operator precedence by inserting your own parentheses and force the original results that we would have seen, had there been no operator precedence (see Example 4-10).
((1 + 2) * 3 - 4) * 5 (2 - 4) * 5 * 3 + 1 (5 + 2 - 4 + 1) * 3
With parentheses correctly inserted, we now see the values 25, −29, and 12, respectively.
Table 4-2 lists PHP’s operators in order of precedence from high to low.
Arithmetic and String
Bitwise (and references)
We’ve been looking at processing expressions from left to right, except where operator precedence is in effect. But some operators can also require processing from right to left. The direction of processing is called the operator’s associativity.
This associativity becomes important in cases in which you do not explicitly force precedence. Table 4-3 lists all the operators that have right-to-left associativity.
Create a new object
Increment and decrement
Unary plus and negation
Cast to an integer
Cast to a float
Cast to a string
Cast to an array
Cast to an object
Inhibit error reporting
For example, let’s take a look at the assignment operator in Example 4-11, where three variables are all set to the value 0.
This multiple assignment is possible only if the rightmost part of the expression is evaluated first and then processing continues in a right-to-left direction.
As a beginner to PHP, you should learn to avoid the potential pitfalls of operator associativity by always nesting your subexpressions within parentheses to force the order of evaluation. This will also help other programmers who may have to maintain your code to understand what is happening.
As already encountered a few times in this chapter, the
equality operator is
equals signs). It is important not to confuse it with the
= (single equals sign) assignment
operator. In Example 4-12, the first
statement assigns a value and the second tests it for
<?php $month = "March"; if ($month == "March") echo "It's springtime"; ?>
As you see, returning either
FALSE, the equality operator enables you
to test for conditions using, for example, an
if statement. But that’s not the whole
story, because PHP is a loosely typed language. If the two operands
of an equality expression are of different types, PHP will convert
them to whatever type makes best sense to it.
For example, any strings composed entirely of numbers will be
converted to numbers whenever compared with a number. In Example 4-13,
$b are two different strings and we would
therefore expect neither of the
if statements to output a
<?php $a = "1000"; $b = "+1000"; if ($a == $b) echo "1"; if ($a === $b) echo "2"; ?>
However, if you run the example, you will see that it outputs
the number 1, which means that the first
if statement evaluated to
TRUE. This is because both strings were
first converted to numbers, and 1000 is the same numerical value as
In contrast, the second
statement uses the identity operator—three
equals signs in a row—which prevents PHP from automatically
$b are therefore compared as strings and
are now found to be different, so nothing is output.
In the same way that you can use the equality operator to test
for operands being equal, you can test for them
not being equal using
!=, the inequality operator. Take a look
at Example 4-14,
which is a rewrite of Example 4-13 in which the
equality and identity operators have been replaced with their
<?php $a = "1000"; $b = "+1000"; if ($a != $b) echo "1"; if ($a !== $b) echo "2"; ?>
And, as you might expect, the first
if statement does not output the number 1,
because the code is asking whether
$b are not equal to
each other numerically.
Instead, it outputs the number 2, because the second
if statement is asking whether
$b are not identical
to each other in their present operand types, and the answer is
TRUE; they are not the
Using comparison operators, you can test for more than just
equality and inequality. PHP also gives you
> (is greater than),
< (is less than),
>= (is greater than or equal to), and
<= (is less than or equal to)
to play with. Example 4-15 shows
these operators in use.
<?php $a = 2; $b = 3; if ($a > $b) echo "$a is greater than $b<br />"; if ($a < $b) echo "$a is less than $b<br />"; if ($a >= $b) echo "$a is greater than or equal to $b<br />"; if ($a <= $b) echo "$a is less than or equal to $b<br />"; ?>
In this example, where
is 2 and
$b is 3, the following
2 is less than 3 2 is less than or equal to 3
Try this example yourself, altering the values of
$b, to see the results. Try setting them
to the same value and see what happens.
Logical operators produce true-or-false results, and therefore are also known as Boolean operators. There are four of them (see Table 4-4).
You can see these operators used in Example 4-16. Note that the
! symbol is required by PHP in place of
NOT. Furthermore, the
operators can be lower- or uppercase.
<?php $a = 1; $b = 0; echo ($a AND $b) . "<br />"; echo ($a or $b) . "<br />"; echo ($a XOR $b) . "<br />"; echo !$a . "<br />"; ?>
This example outputs
NULL, meaning that only the
second and third
TRUE. (Remember that
NULL—or nothing—represents a
FALSE.) This is because
AND statement requires both
operands to be
TRUE if it is
going to return a value of
while the fourth statement performs a
NOT on the value of
$a, turning it from
TRUE (a value of 1) to
FALSE. If you wish to experiment with
this, try out the code, giving
$b varying values of 1 and
When coding, remember to bear in mind that
OR have lower precedence than the other
versions of the operators,
||. In complex expressions, it may be
safer to use
|| for this reason.
OR operator can cause
unintentional problems in
statements, because the second operand will not be evaluated if the
first is evaluated as
Example 4-17, the function
getnext will never be called if
$finished has a value of
If you need
getnext to be
called at each
if statement, you
should rewrite the code as has been done in Example 4-18.
<?php $gn = getnext(); if ($finished == 1 OR $gn == 1) exit; ?>
In this case, the code in function
getnext will be executed and the value
returned stored in
$gn before the
Table 4-5 shows
all the possible variations of using the logical operators. You
should also note that