## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

No credit card required

## Operators

PHP offers a lot of powerful operators that range from arithmetic, string, and logical operators to assignment, comparison, and more (see Table 4-1).

Table 4-1. PHP operator types
 Operator Description Example Arithmetic Basic mathematics `\$a + \$b` Array Array union `\$a + \$b` Assignment Assign values `\$a = \$b + 23` Bitwise Manipulate bits within bytes `12 ^ 9` Comparison Compare two values `\$a < \$b` Execution Executes contents of backticks ``ls -al`` Increment/Decrement Add or subtract 1 `\$a++` Logical Boolean `\$a and \$b` String Concatenation `\$a . \$b`

Each operator takes a different number of operands:

• Unary operators, such as incrementing (`\$a++`) or negation (`-\$a`), which take a single operand.

• Binary operators, which represent the bulk of PHP operators, including addition, subtraction, multiplication, and division.

• One ternary operator, which takes the form `? x : y`. It’s a terse, single-line `if` statement that chooses between two expressions, depending on the result of a third one.

### Operator Precedence

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.

Example 4-5. Three equivalent expressions
```1 + 2 + 3 - 4 + 5
2 - 4 + 5 + 3 + 1
5 + 2 - 4 + 1 + 3```

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).

Example 4-6. Three expressions that are also equivalent
```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.

Example 4-7. Three expressions using operators of mixed precedence
```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.

Example 4-8. Three expressions showing implied parentheses
```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.

Example 4-9. After evaluating the subexpressions in parentheses
```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).

Example 4-10. Forcing left-to-right evaluation
```((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.

Table 4-2. The precedence of PHP operators (high to low)
 Operator(s) Type `()` Parentheses `++ --` Increment/Decrement `!` Logical `* / %` Arithmetic `+ - .` Arithmetic and String `<< >>` Bitwise ```< <= > >= <>``` Comparison `== != === !==` Comparison `&` Bitwise (and references) `^` Bitwise `|` Bitwise `&&` Logical `||` Logical `? :` Ternary ```= += -= *= /= .= %= &= != ^= <<= >>=``` Assignment `and` Logical `xor` Logical `or` Logical

### Associativity

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.

Table 4-3. Operators with right-to-left associativity
 Operator Description `NEW` Create a new object `!` Logical NOT `~` Bitwise NOT `++ --` Increment and decrement `+ -` Unary plus and negation `(int)` Cast to an integer `(double)` Cast to a float `(string)` Cast to a string `(array)` Cast to an array `(object)` Cast to an object `@` Inhibit error reporting `=` Assignment

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.

Example 4-11. A multiple-assignment statement
```<?php
\$level = \$score = \$time = 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.

### Note

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.

### Relational Operators

Relational operators test two operands and return a Boolean result of either `TRUE` or `FALSE`. There are three types of relational operators: equality, comparison, and logical.

#### Equality

As already encountered a few times in this chapter, the equality operator is `==` (two 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 equality.

Example 4-12. Assigning a value and testing for equality
```<?php
\$month = "March";
if (\$month == "March") echo "It's springtime";
?>```

As you see, returning either `TRUE` or `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, `\$a` and `\$b` are two different strings and we would therefore expect neither of the `if` statements to output a result.

Example 4-13. The equality and identity operators
```<?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 +1000.

In contrast, the second `if` statement uses the identity operator—three equals signs in a row—which prevents PHP from automatically converting types. `\$a` and `\$b` are therefore compared as strings and are now found to be different, so nothing is output.

As with forcing operator precedence, whenever you feel there may be doubt about how PHP will convert operand types, you can use the identity operator to turn this behavior off.

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 inverses.

Example 4-14. The inequality and not identical operators
```<?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 `\$a` and `\$b` are not equal to each other numerically.

Instead, it outputs the number 2, because the second `if` statement is asking whether `\$a` and `\$b` are not identical to each other in their present operand types, and the answer is `TRUE`; they are not the same.

#### Comparison operators

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.

Example 4-15. The four comparison operators
```<?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 `\$a` is 2 and `\$b` is 3, the following is output:

```2 is less than 3
2 is less than or equal to 3```

Try this example yourself, altering the values of `\$a` and `\$b`, to see the results. Try setting them to the same value and see what happens.

#### Logical operators

Logical operators produce true-or-false results, and therefore are also known as Boolean operators. There are four of them (see Table 4-4).

Table 4-4. The logical operators
 Logical operator Description `AND` `TRUE` if both operands are `TRUE` `OR` `TRUE` if either operand is `TRUE` `XOR` `TRUE` if one of the two operands is `TRUE` `NOT` `TRUE` if the operand is `FALSE` or `FALSE` if the operand is `TRUE`

You can see these operators used in Example 4-16. Note that the `!` symbol is required by PHP in place of the word `NOT`. Furthermore, the operators can be lower- or uppercase.

Example 4-16. The logical operators in use
```<?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`, 1, 1, `NULL`, meaning that only the second and third `echo` statements evaluate as `TRUE`. (Remember that `NULL`—or nothing—represents a value of `FALSE`.) This is because the `AND` statement requires both operands to be `TRUE` if it is going to return a value of `TRUE`, 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 `\$a` and `\$b` varying values of 1 and 0.

### Note

When coding, remember to bear in mind that `AND` and `OR` have lower precedence than the other versions of the operators, `&&` and `||`. In complex expressions, it may be safer to use `&&` and `||` for this reason.

The `OR` operator can cause unintentional problems in `if` statements, because the second operand will not be evaluated if the first is evaluated as `TRUE`. In Example 4-17, the function `getnext` will never be called if `\$finished` has a value of 1.

Example 4-17. A statement using the OR operator
```<?php
if (\$finished == 1 OR getnext() == 1) exit;
?>```

If you need `getnext` to be called at each `if` statement, you should rewrite the code as has been done in Example 4-18.

Example 4-18. The “if ... OR” statement modified to ensure calling of getnext
```<?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 `if` statement.

Table 4-5 shows all the possible variations of using the logical operators. You should also note that `!TRUE` equals `FALSE` and `!FALSE` equals `TRUE`.

Table 4-5. All possible PHP logical expressions
 Inputs Operators and results a b AND OR XOR `TRUE` `TRUE` `TRUE` `TRUE` `FALSE` `TRUE` `FALSE` `FALSE` `TRUE` `TRUE` `FALSE` `TRUE` `FALSE` `TRUE` `TRUE` `FALSE` `FALSE` `FALSE` `FALSE` `FALSE`

## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, interactive tutorials, and more.

No credit card required