Operators:

An operator is something that you feed with one or more values (or expressions, in programming jargon)
which yields another value (so that the construction itself becomes an expression). So you can think of
functions or constructions that return a value (like print) as operators and those that return nothing (like
echo) as any other thing.

There are three types of operators. Firstly there is the unary operator which operates on only one
value, for example ! (the negation operator) or ++ (the increment operator). The second group are
termed binary operators; this group contains most of the operators that PHP supports, and a list follows
below in the section Operator Precedence.

The third group is the ternary operator: ?:. It should be used to select between two expressions
depending on a third one, rather than to select two sentences or paths of execution. Surrounding ternary
expressions with parentheses is a very good idea.

Operator Precedence

The precedence of an operator specifies how "tightly" it binds two expressions

together.

For example, in the expression 1 + 5 * 3, the answer is 16 and not 18 because the multiplication ("*")
operator has a higher precedence than the addition ("+") operator. Parentheses may be used to force
precedence, if necessary. For instance: (1 + 5) * 3 evaluates to 18.

If operator precedence is equal, left to right associativity is used.

The following table lists the precedence of operators with the highest-precedence operators listed at the
top of the table. Operators on the same line have equal precedence, in which case their associativity
decides which order to evaluate them in.

Table 15.1. Operator Precedence

Associativity Operators Additional Information

non-associative new new
left [ array()
non-associative ++ -- increment/decrement
non-associative ~ - (int) (float) (string) (array) (object) @ types
non-associative instanceof types
right ! logical
left */% arithmetic
left +-. arithmetic and string
 Associativity Operators Additional Information
left << >> bitwise
non-associative < <= > >= comparison
non-associative == != === !== comparison
left & bitwise and references
left ^ bitwise
left | bitwise
left && logical
left || logical
left ?: ternary
right = += -= *= /= .= %= &= |= ^= <<= >>= assignment
left and logical
left xor logical
left or logical
left , many uses

Left associativity means that the expression is evaluated from left to right, right associativity
means the opposite.

Example 15.1. Associativity

<?php
$a = 3 * 3 % 5; // (3 * 3) % 5 = 4
$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2

$a = 1;
$b = 2;
$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
?>

Use parentheses to increase readability of the code.

Note: Although = has a lower precedence than most other operators, PHP will still allow expressions

similar to the following: if (!$a = foo()), in which case the return value of foo() is put into $a.

Arithmetic Operators

Remember basic arithmetic from school? These work just like those.
Table 15.2. Arithmetic Operators

Example Name Result

-$a Negation Opposite of $a.
$a + $b Addition Sum of $a and $b.
$a - $b Subtraction Difference of $a and $b.
$a * $b Multiplication Product of $a and $b.
$a / $b Division Quotient of $a and $b.
$a % $b Modulus Remainder of $a divided by $b.

The division operator ("/") returns a float value unless the two operands are integers (or strings that
get converted to integers) and the numbers are evenly divisible, in which case an integer value will be
returned.

Operands of modulus are converted to integers (by stripping the decimal part) before
processing.
Note: Remainder $a % $b is negative for negative $a.

Assignment Operators

The basic assignment operator is "=". Your first inclination might be to think of this as "equal to". Don't. It
really means that the left operand gets set to the value of the expression on the rights (that is, "gets set to").

The value of an assignment expression is the value assigned. That is, the value of "$a = 3" is 3. This
allows you to do some tricky things:

<?php

$a = ($b = 4) + 5; // $a is equal to 9 now, and $b has been set to 4.

?>

In addition to the basic assignment operator, there are "combined operators" for all of the binary
arithmetic, array union and string operators that allow you to use a value in an expression and then set its
value to the result of that expression. For example:

<?php

$a = 3;
$a += 5; // sets $a to 8, as if we had said: $a = $a + 5;
$b = "Hello ";
$b .= "There!"; // sets $b to "Hello There!", just like $b = $b . "There!";
?>
Note that the assignment copies the original variable to the new one (assignment by
value), so changes to one will not affect the other.

This may also have relevance if you need to copy something like a large array inside a tight loop.
Since PHP 4, assignment by reference has been supported, using the $var = &$othervar; syntax, but
this is not possible in PHP 3. 'Assignment by reference' means that both variables end up pointing
at the same data, and nothing is copied anywhere. To learn more about references, please read
References explained. As of PHP 5, objects are assigned by reference unless explicitly told otherwise
with the new clone keyword.

Bitwise Operators

Bitwise operators allow you to turn specific bits within an integer on or off. If both the left- and right-
hand parameters are strings, the bitwise operator will operate on the characters' ASCII values.

<?php
echo 12 ^ 9; // Outputs '5'

echo "12" ^ "9"; // Outputs the Backspace character (ascii 8)

// ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8

echo "hallo" ^ "hello"; // Outputs the ascii values #0 #4 #0 #0 #0

// 'a' ^ 'e' = #4
?>
Warning
Don't right shift for more than 32 bits on 32 bits systems. Don't left shift in case it results to
number longer than 32 bits.

What is a bit? A bit is a representation of 1 or 0. Basically OFF and ON. Why do computers use such
simple math? Well computers process with electric current so if the current is over a certain level the
computer considers that to mean ON or 1 and if it is under that level it is set to OFF or 0.

What is a byte? A byte is made up of 8 bits and the highest value of a byte is 255, which would
mean every bit is set. We will look at why a byte's maximum value is 255 in just a second.

What does a byte look like?

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1

That is a representation of 1 Byte.

The "Place Value" column represents the math we did doing 2 to the power of 7,6,5,4,3,2,1,0
So if all bits are set and the value = 255 my byte would look like this

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
1 1 1 1 1 1 1 1 = 255
How do we get 255?

Lets take it right to left and add up all those values together
1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255

What would the number 22 look like?

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
0 0 0 1 0 1 1 0 = 22
2 + 4 + 16 = 22

Lets look at some other examples of decimal to binary, the ones on the end try for yourself.

43 = 00101011
4 = 00000100
230 = ?
65 = ?
31 = ?

PART II PHP'S BITWISE OPERATORS

You can find complete detail on the PHP bitwise operators here:
http://www.php.net/manual/en/language.operators.bitwise.php

What are going to cover?

We're going to cover the bitwise operators below and see how they work

Example Name Result

$a & $b And Bits that are set in both $a and $b are set.
$a | $b Or Bits that are set in either $a or $b are set.
$a ^ $b Xor Bits that are set in $a or $b but not both are set.
~ $a Not Bits that are set in $a are not set, and vice versa.
$a << $b Shift left Shift the bits of $a $b steps to the left (each step means "multiply by two")
Example Name Result
$a >> $b Shift right Shift the bits of $a $b steps to the right (each step means "divide by two")

Lets use two variables to get started with the "And" operator &.
The & or "And" operator takes two values and returns a decimal version of the binary values the left and
right variable share. So using our tables above we can see that the only bit these two share is in the 8
position so $a & $b = 8.

$a = 9;
$b = 10;
echo $a & $b;

This would output the number 8. Why?? Well lets see using our table example

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a 0 0 0 0 1 0 0 1 = 9
$b 0 0 0 0 1 0 1 0 = 10

So you can see from the table the only bit they share together is the 8 bit. So 8 gets returned.. not too hard
eh? Lets look at another example of the & operator.

$a = 36;
$b = 103;
echo $a & $b;

This would output the number 36. Why?? Well lets see using our table example again

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a 0 0 1 0 0 1 0 0 = 36
$b 0 1 1 0 0 1 1 1 = 103

So you can see the only bits these two share together are the bits 32 and 4 which when added together
return 36. This operator is saying "I want to know what bits you both have set in the same column"

Lets move on to the | also known as the "OR" operator.

$a = 9;
$b = 10;
echo $a | $b;

This would output the number 11. Why?? Well lets see using our table example

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a 0 0 0 0 1 0 0 1 = 9
$b 0 0 0 0 1 0 1 0 = 10

If you notice we have 3 bits set, in the 8, 2, and 1 column.. add those up 8+2+1 and you get 11. It is just
saying "I want to know what bits either one of you guys have set".

Moving on to the ^ operator also known as the "Xor" operator.

$a = 9;
$b = 10;
echo $a ^ $b;

This would output the number 3. Why?? Well lets see using our table example

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a 0 0 0 0 1 0 0 1 = 9
$b 0 0 0 0 1 0 1 0 = 10

The XOR operator wants to know "Tell me what bits you both have set but I dont want any bits you share"
Notice we have 3 bits set but both $a and $b share the 8 bit, we dont want that one, we just want the 2 bit
and the 1 bit that they each have set but don't share. Soooo 2+1 = 3

OK, here is one that gets tricky the ~ operator also known as the "NOT" operator.
$a = 9;
$b = 10;
echo $a & ~$b;

This would output the number 1. Why?? Well lets see using our table example

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a 0 0 0 0 1 0 0 1 = 9
$b 0 0 0 0 1 0 1 0 = 10
The NOT operator wants to know what is set in $a but NOT set in $b because we marked $b with the
~operator in front of it. So looking at our table we can see the only bit set in $a thats not in $b is 1.

What happens if we do this...

$a = 9;
$b = 10;
echo ~$a & $b;

We get the value 2, because we want the bits set in $b but NOT set in $a this time, so since they both share
the 8 bit, 2 bit is the only one $b has that $a does not.

BIT SHIFTING TIME!!!

$a = 16;
echo $a << 2;

This would output the number 64. Why?? Well lets see using our table example

1 Byte ( 8 bits )
Place Value 128 64 32 16 8 4 2 1
$a - BEFORE! 0 0 0 1 0 0 0 0 = 16
$a - AFTER! 0 1 0 0 0 0 0 0 = 64

How do we get 64? well bit shifting tells PHP to take the variable $a which in our case is 16 and shift if 2
bits which is basically like saying take 16 and multiply it by 2 twice. So 16 X 2 = 32 x 2 = 64

So what useful things can you do with the bitwise operations?

Here is a VERY simple and watered down user persmissions system. This is great if you have many
classes of persmission for users for example...

a user can...
read articles
write articles
edit articles
be an local Administrator
be a global Administrator

So you can setup your permission rules like this in your configuration file

1. <?php
2. $read = 1;
3. $write = 2;
4. $readwrite = 16;
5. $local_admin = 32;
6. $global_admin = 64;
7.
8. $jim = 96;
9. $mike = 16;
10.
11. echo "Is Mike Allowed to edit? he has an access level of 16<BR>";
12. if($mike & 32)
13. {
14. echo 'YES MIKE CAN EDIT';
15. } else {
16. echo 'NO HE CANNOT';
17. }
18.
19. echo "<BR><BR>Is Jim Allowed to edit? he has an access level of
96<BR>";
20. if($jim & 32)
21. {
22. echo 'YES JIM CAN EDIT';
23. } else {
24. echo 'NO HE CANNOT';
25. }

26. ?>

When you run that code you'll see

Is Mike Allowed to edit? he has an access level of 16

NO HE CANNOT

Is Jim Allowed to edit? he has an access level of 32

YES JIM CAN EDIT

Using the AND operator we can clearly see if Mike has the 32 bit set that is required for this local admin
operation, not only is Jim a local admin but he's also a global admin with the 64 and 32 bit set giving him
a 96 permission level. Imagine if you had 20 different levels of access in your application, being able
to store all those in a single integer is VERY handy instead of having to do something like

if(is_local_admin && is_global_admin && can_edit_articles && can_view_articles) etc.... that

could get long, ugly and hard to manage.
Comparison Operators

Comparison operators, as their name implies, allow you to compare two values. You may also be
interested in viewing the type comparison tables, as they show examples of various type related
comparisons.

Table 15.4. Comparison Operators

Example Name Result

$a == $b Equal TRUE if $a is equal to $b.
TRUEif $a is equal to $b, and they are of the same type. (introduced in
$a === $b Identical
PHP 4)
$a != $b Not equal TRUE if $a is not equal to $b.
$a <> $b Not equal TRUE if $a is not equal to $b.
TRUE if $a is not equal to $b, or they are not of the same type. (introduced
$a !== $b Not identical
in PHP 4)
$a < $b Less than TRUE if $a is strictly less than $b.
$a > $b Greater than TRUE if $a is strictly greater than $b.
$a <= $b Less than or equal to TRUE if $a is less than or equal to $b.
Greater than or equal
$a >= $b TRUE if $a is greater than or equal to $b.
to

If you compare an integer with a string, the string is converted to a number. If you
compare two numerical strings, they are compared as integers. These rules also apply
to the switch statement.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("1" == "1e0"); // 1 == 1 -> true

switch ("a") {
case 0:
echo "0";
break;
case "a": // never reached because "a" is already matched with 0
echo "a";
break;
}
?>

For various types, comparison is done according to the following table (in order).

Table 15.5. Comparison with Various Types

 Type of Type of
Result
Operand 1 Operand 2
null or string string Convert NULL to "", numerical or lexical comparison
bool or null anything Convert to bool, FALSE < TRUE
Built-in classes can define its own comparison, different classes are
object object uncomparable, same class - compare properties the same way as
arrays (PHP 4), PHP 5 has its own explanation
string, resource string, resource
Translate strings and resources to numbers, usual math
or number or number
Array with fewer members is smaller, if key from operand 1 is not
array array found in operand 2 then arrays are uncomparable, otherwise -
compare value by value (see following example)
array anything array is always greater
object anything object is always greater

Example 15.2. Transcription of standard array comparison

<?php
// Arrays are compared like this with standard comparison operators
function standard_array_compare($op1, $op2)
{
if (count($op1) < count($op2)) {
return -1; // $op1 < $op2
} elseif (count($op1) > count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // uncomparable
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>

See also strcasecmp(), strcmp(), Array operators, and the manual section on Types.

Ternary Operator

Another conditional operator is the "?:" (or ternary) operator.

Example 15.3. Assigning a default value

<?php
// Example usage for: Ternary Operator
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// The above is identical to this if/else statement

if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}

?>

The expression (expr1) ? (expr2) : (expr3) evaluates to expr2 if expr1 evaluates to TRUE, and expr3 if
expr1 evaluates to FALSE.

Note: Please note that the ternary operator is a statement, and that it doesn't evaluate to a variable, but to
the result of a statement. This is important to know if you want to return a variable by reference. The
statement return $var == 42 ? $a : $b; in a return-by-reference function will therefore not work and a
warning is issued in later PHP versions.

Note: Is is recommended that you avoid "stacking" ternary expressions. PHP's behaviour when using
more than one ternary operator within a single statement is non-obvious:

Example 15.4. Non-obvious Ternary Behaviour

<?php
// on first glance, the following appears to output 'true'
echo (true?'true':false?'t':'f');

// however, the actual output of the above is 't'

// this is because ternary expressions are evaluated from left to right

// the following is a more obvious version of the same code as above

echo ((true ? 'true' : 'false') ? 't' : 'f');

// here, you can see that the first expression is evaluated to 'true', which
// in turn evaluates to (bool)true, thus returning the true branch of the
// second ternary expression.
?>

Error Control Operators

PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any
error messages that might be generated by that expression will be ignored.
If the track_errors feature is enabled, any error message generated by the expression will be saved in the
variable $php_errormsg. This variable will be overwritten on each error, so check early if you want to use
it.

<?php
/* Intentional file error */
$my_file = @file ('non_existent_file') or
die ("Failed opening file: error was '$php_errormsg'");

// this works for any expression, not just functions:

$value = @$cache[$key];
// will not issue a notice if the index $key doesn't exist.

?>
Note: The @-operator works only on expressions. A simple rule of thumb is: if you
can take the value of something, you can prepend the @ operator to it. For instance,
you can prepend it to variables, function and include() calls, constants, and so forth.
You cannot prepend it to function or class definitions, or conditional structures such
as if and foreach, and so forth.

See also error_reporting() and the manual section for Error Handling and Logging functions.

Warning

Currently the "@" error-control operator prefix will even disable error reporting for critical errors that will
terminate script execution. Among other things, this means that if you use "@" to suppress errors from a
certain function and either it isn't available or has been mistyped, the script will die right there with no
indication as to why.

Incrementing/Decrementing Operators

PHP supports C-style pre- and post-increment and decrement operators.

Note: The increment/decrement operators do not affect boolean values. Decrementing

NULL values has no effect too, but incrementing them results in 1.

Table 15.6. Increment/decrement Operators

Example Name Effect

++$a Pre-increment Increments $a by one, then returns $a.
$a++ Post-increment Returns $a, then increments $a by one.
--$a Pre-decrement Decrements $a by one, then returns $a.
$a-- Post-decrement Returns $a, then decrements $a by one.
Here's a simple example script:

<?php
echo "<h3>Postincrement</h3>";
$a = 5;
echo "Should be 5: " . $a++ . "<br />\n";
echo "Should be 6: " . $a . "<br />\n";

echo "<h3>Preincrement</h3>";
$a = 5;
echo "Should be 6: " . ++$a . "<br />\n";
echo "Should be 6: " . $a . "<br />\n";

echo "<h3>Postdecrement</h3>";
$a = 5;
echo "Should be 5: " . $a-- . "<br />\n";
echo "Should be 4: " . $a . "<br />\n";

echo "<h3>Predecrement</h3>";
$a = 5;
echo "Should be 4: " . --$a . "<br />\n";
echo "Should be 4: " . $a . "<br />\n";
?>
PHP follows Perl's convention when dealing with arithmetic operations on character
variables and not C's. For example, in Perl 'Z'+1 turns into 'AA', while in C 'Z'+1 turns into
'[' ( ord('Z') == 90, ord('[') == 91 ). Note that character variables can be incremented but not
decremented and even so only plain ASCII characters (a-z and A-Z) are supported.

Example 15.5. Arithmetic Operations on Character Variables

<?php
$i = 'W';
for ($n=0; $n<6; $n++) {
echo ++$i . "\n";
}
?>

The above example will output:

X
Y
Z
AA
AB
AC

Incrementing or decrementing booleans has no effect.

Logical Operators

Table 15.7. Logical Operators

Example Name Result

$a and $b And TRUE if both $a and $b are TRUE.
$a or $b Or TRUE if either $a or $b is TRUE.
$a xor $b Xor TRUE if either $a or $b is TRUE, but not both.
! $a Not TRUE if $a is not TRUE.
$a && $b And TRUE if both $a and $b are TRUE.
$a || $b Or TRUE if either $a or $b is TRUE.

The reason for the two different variations of "and" and "or" operators is that they operate
at different precedences. (See Operator Precedence.)

Example 15.6. Logical operators illustrated

<?php

// foo() will never get called as those operators are short-circuit

$a = (false && foo());
$b = (true || foo());
$c = (false and foo());
$d = (true or foo());

// "||" has a greater precedence than "or"

$e = false || true; // $e will be assigned to (false || true) which is true
$f = false or true; // $f will be assigned to false
var_dump($e, $f);

// "&&" has a greater precedence than "and"

$g = true && false; // $g will be assigned to (true && false) which is false
$h = true and false; // $h will be assigned to true
var_dump($g, $h);
?>

The above example will output something similar to:

bool(true)
bool(false)
bool(false)
bool(true)
String Operators

There are two string operators. The first is the concatenation operator ('.'), which returns the concatenation
of its right and left arguments. The second is the concatenating assignment operator ('.='), which appends
the argument on the right side to the argument on the left side. Please read Assignment Operators for more
information.

<?php
$a = "Hello ";
$b = $a . "World!"; // now $b contains "Hello World!"

$a = "Hello ";
$a .= "World!"; // now $a contains "Hello World!"
?>

See also the manual sections on the String type and String functions.

Array Operators

Table 15.8. Array Operators

Example Name Result

$a + $b Union Union of $a and $b.
$a == $b Equality TRUE if $a and $b have the same key/value pairs.
TRUEif $a and $b have the same key/value pairs in the same order and of the
$a === $b Identity
same types.
$a != $b Inequality TRUE if $a is not equal to $b.
$a <> $b Inequality TRUE if $a is not equal to $b.
$a !== $b Non-identity TRUE if $a is not identical to $b.

The + operator appends elements of remaining keys from the right handed array to the left handed,
whereas duplicated keys are NOT overwritten.

<?php
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");

$c = $a + $b; // Union of $a and $b

echo "Union of \$a and \$b: \n";
var_dump($c);

$c = $b + $a; // Union of $b and $a

echo "Union of \$b and \$a: \n";
var_dump($c);
?>
When executed, this script will print the following: Union of $a and $b:
array(3) {
["a"]=>
string(5) "apple"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "cherry"
}
Union of $b and $a:
array(3) {
["a"]=>
string(4) "pear"
["b"]=>
string(10) "strawberry"
["c"]=>
string(6) "cherry"
}

Elements of arrays are equal for the comparison if they have the same key and value.

Example 15.7. Comparing arrays

<?php
$a = array("apple", "banana");
$b = array(1 => "banana", "0" => "apple");

var_dump($a == $b); // bool(true)

var_dump($a === $b); // bool(false)
?>

See also the manual sections on the Array type and Array functions.

Type Operators

instanceof is used to determine whether a PHP variable is an instantiated object of a certain

class:

Example 15.8. Using instanceof with classes

<?php
class MyClass
{
}
class NotMyClass
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);

var_dump($a instanceof NotMyClass);
?>

The above example will output:

bool(true)
bool(false)

instanceof can also be used to determine whether a variable is an instantiated object of a

class that inherits from a parent class:

Example 15.9. Using instanceof with inherited classes

<?php
class ParentClass
{
}
class MyClass extends ParentClass
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);

var_dump($a instanceof ParentClass);
?>

The above example will output:

bool(true)
bool(true)

Lastly, instanceof can also be used to determine whether a variable is an instantiated object
of a class that implements an interface:

Example 15.10. Using instanceof for class

<?php
interface MyInterface
{
}
class MyClass implements MyInterface
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);

var_dump($a instanceof MyInterface);
?>

The above example will output:

bool(true)
bool(true)

Although instanceof is usually used with a literal classname, it can also be used with another
object or a string variable:

Example 15.11. Using instanceof with other variables

<?php
interface MyInterface
{
}
class MyClass implements MyInterface
{
}
$a = new MyClass;
$b = new MyClass;
$c = 'MyClass';
$d = 'NotMyClass';
var_dump($a instanceof $b); // $b is an object of class MyClass
var_dump($a instanceof $c); // $c is a string 'MyClass'
var_dump($a instanceof $d); // $d is a string 'NotMyClass'
?>

The above example will output:

bool(true)
bool(true)
bool(false)

There are a few pitfalls to be aware of. Before PHP version 5.1.0, instanceof would call __autoload()
if the class name did not exist. In addition, if the class was not loaded, a fatal error would occur. This
can be worked around by using a dynamic class reference, or a string variable containing the class
name:

Example 15.12. Avoiding classname lookups and fatal errors with instanceof in PHP 5.0

<?php
$d = 'NotMyClass';
var_dump($a instanceof $d); // no fatal error here
?>

The above example will output:

bool(false)

The instanceof operator was introduced in PHP 5. Before this time is_a() was used but is_a() has since
been deprecated in favor of instanceof.

See also get_class() and is_a().