PHP Operations

In the world of programming, there are tons and tons of operations some of which can be performed on numbers, some on strings, some on Booleans, some on any arbitrary value, and so on.

But what exactly is an operation?

A very simple example of an operation is that of addition. Addition, as we all know, is to sum up two numbers together.

Now as it turns out, every single operation in a language has to be represented in some way by some symbol or keywrord.

For instance, addition is represented by the symbol +. Similarly, string concatenation is represented by the symbol ., and so on.

Such a symbol or keyword has a special name i.e. an operator.

Certain operators require two values to operate such as the arithmetic operators (addition, subtraction, etc.), concatenation, etc. These operators are known as binary operators, where the term 'binary' represents 'two'.

Then there are operators than only require one value. These are known as unary operators. Examples include post-increment ++ as in $i++.

There is even a ternary operator in PHP, more generally called as the conditional operator. We'll explore it in the PHP Control Flow unit.

The values required to be put around an operator, on which the underlying operation is performed, are known as operands.

For instance, in the expression 2 + 5, 2 and 5 are the operands, + is the operator, and the operation being performed is addition.

With this distinction in mind as to what is an operation, an operator and an operand, it's time to finally see all the different kinds of operators in PHP.

Nearly all programming languages allows the programmer to perform the elementary arithmetic operations on numbers. PHP is no way behind.

We've seen all the basic arithmetic operations in the previous chapters. The likes of addition, subtraction, multiplication, division, exponentiation and modulo.

Here's a quick recap:

The snippet below demonstrates all these operations:

<?php

$x = 2;
$y = 10;

echo 'Addition: ', $x + $y, "\n";
echo 'Subtraction: ', $x - $y, "\n";
echo 'Multiplication: ', $x * $y, "\n";
echo 'Division: ', $x / $y, "\n";
echo 'Exponentiation: ', $x ** $y, "\n";
echo 'Modulo: ', $x % $y, "\n";

Simple.

When working with control flow structures in PHP, it's extremely common to compare different values to one another. For instance, before printing 'Even', we'd have to check if an integer is even. This is done using the === and the % operators.

Relational operators are what enable us to compare two values to one another. The word 'relational' comes from the fact that the operator describes a relation between the given operands, for example, whether they are equal to one another or not.

Sometimes relational operators are also referred to as comparison operators in PHP.

Below shown is a list of the most common relational operators in PHP:

Let's try to put all of these operations into real examples.

Suppose we want to print 'Even' if a given integer $a is even or else print 'Odd'. This can be accomplished as follows:

<?php

$a = 10;

if ($a % 2 === 0) {
   echo 'Even';
}
else {
   echo 'Odd';
}

First we check $a for an even parity and then fallback with the case that it's odd.

This same idea can also be accomplished using the non-identity operator (!==) by switching the conditional cases, as follows:

<?php

$a = 10;

if ($a % 2 !== 0) {
   echo 'Odd';
}
else {
   echo 'Even';
}

Here, first we check $a for an odd parity and then fallback with the case that it's even.

Let's consider another example.

Suppose we want to print 'Above 18' if a given variable $age is greater than 18, or else print 'Not above 18'. This is done below using the greater-than (>) operator:

<?php

$age = 18;

if ($age > 18) {
   echo 'Above 18';
}
else {
   echo 'Not above 18';
}

As before, the same idea can be accomplished by reversing the conditional cases and using the less-than or equal to (<=) operator:

<?php

$age = 18;

if ($age <= 18) {
   echo 'Not above 18';
}
else {
   echo 'Above 18';
}

First we check if $a is less than or equal to 18 and print 'Not above 18' if it is. Else, we assume that $age is greater than 18 and likewise print 'Above 18'

One thing that we're not doing above is that we're not checking if the value stored in $age is really an integer.

For instance, in the last code snippet above, if $age is not an integer, the else block is executed ultimately printing 'Above 18'.

This problem can be rectified very easily, thanks to the is_int() function we learned about before.

Consider the code below:

<?php

$age = 'random';

if (is_int($age) === false) {
   echo 'Invalid value';
}
elseif ($age <= 18) {
   echo 'Not above 18';
}
else {
   echo 'Above 18';
}

Needless to say, assignment is by far one of the most common and useful operations in any programming language. There are tons and tons of variables created in all but the simplest programs.

Typically, the = symbol is used as the assignment operator in most languages and that's exactly the case with PHP.

Consider the code below:

<?php

$i = 0;

We create a variable $i and assign it the value 0.

Note that the left-hand side of an assignment operation can only host a variable (or any identifier where something can be stored). It's illegal to put any arbitrary expression there.

For example, in the code below, we write 10 on the left-hand side of = and consequently get a syntax error.

<?php

10 = 0;

So far is this course we've been treating assignment as a standalone statement. However, since it's an operation, assignment is merely an expression. And we know that all expressions resolve down to a value, right?

Similarly, the assignment operation evaluates down to the value assigned to the variable (or identifier).

This can be seen below:

<?php

echo $i = 0;

We echo the expression $i = 0 directly instead of first defining it on a separate line and then printing it. Regardless, since it's an expression that, in this case, resolves down to 0, 0 is ultimately printed.

Moreover, following from the fact that assignment resolves down to the value assigned, we can define and assign multiple variables in one go instead of putting each assignment on a separate line.

Consider the code below:

<?php

$a = 0;
$b = 0;
$x = 0;
$y = 0;

Here we are trying to define four variables $a, $b, $x and $y, each set to 0. The code isn't obviously wrong, but a little bit too long.

Using the power of assignment, we can easily express this same notion as follows:

<?php

$a = $b = $x = $y = 0;

The way this works is very simple. Once the engine is done parsing the source code, it begins evaluating each = starting from the right-hand side. That is, first $y = 0 is evaluated. This defines $y, sets it to 0, and returns 0.

Next up, $x = 0 is evaluated (where the 0 is the result of the first evaluation) and the same process repeats. This goes on until 0 is assigned to $a at which point the whole statement completes.

Apart from the mere assignment operator, PHP provides multiple assignment operators that do more than just assignment. These operators perform a certain operation on the given operands and then assign a value to one of them.

The table below shows some of these:

Let's take the addition-assignment (+=) operator. Consider the code below:

<?php

$a = 10;
$b = 60;

echo $a += $b;

The expression $a += $b first adds $a and $b together, then assigns the result to $a, and then finally returns the result. Thus, 70 is printed.

You might be thinking that this is redundant and that we could easily do something $i = $i + 10 instead of $i ++ 10. In other words, you might be thinking that there isn't really a big deal to these special assignment operators.

Well, these special operators only start to show their advantage once we try to operate and assign to an identifier that's very long when written.

For instance, as we'll see later in the OOP unit, it's common to refer to properties of a given object one after another to reach a given property and then assign to it meanwhile performing an operation:

Consider the code below:

<?php

/* ... */

// Increase the vote count by 10.
$user_store->question(1)->votes = $user_store->question(1)->votes + 10;

Here we try to add 10 to the given identifier $user_store->question(1)->votes and assign the result back to it. As can be seen, the expression has become quite long due to the repetition of the identifier.

A much better approach would be to use the += operator instead. This is what we do below:

<?php

/* ... */

// Increase the vote count by 10.
$user_store->question(1)->votes += 10;

Short and concise.

Combining Booleans together is a routine activity in conditional programming. The world of electronics and computing has much to say to Boolean operations, also known as logical operations.

They come directly from the beautiful mathematical theory of propositions and propositional operators.

So what are logical operation?

The three most common logical operations in PHP and most languages are logical NOT, OR, and AND. The table below summarizes them along with their respective operators.

Let's consider some examples.

Recall from the previous discussion an if statement set up with the condition is_int($age) === false:

<?php

$age = 'random';

if (is_int($age) === false) {
   echo 'Invalid value';
}
elseif ($age <= 18) {
   echo 'Not above 18';
}
else {
   echo 'Above 18';
}

Clearly, we can see that we mean to execute a piece of code in the if statement if $age is not an integer i.e. is_int($age) returns false.

A better approach would be use the logical NOT operator in this case.

The following table summarizes the semantics of !:

Taking this idea to our previous example, we want to print 'Invalid value' if $age is not an integer. Hence, we need to check for the condition !is_int($age). If this expression evaluates to true, that simpy means that is_int() returned false.

<?php

$age = 'random';

if (!is_int($age)) {
   echo 'Invalid value';
}
elseif ($age <= 18) {
   echo 'Not above 18';
}
else {
   echo 'Above 18';
}

Simple.

As we'll see in the following chapters in this course, ! is not something used occasionally — it's an extremely common and useful operator.

Moving on, often times it's desirable to combine multiple conditions with one another. That's where the logical OR and the logical AND operators come into the game.

Here's a table summarizing the semantics of ||:

Let's consider an example:

Suppose we want to print 'Divisible by 2 or 3' if an integer $x is divisible by 2 or by 3, or by both.

In the typical if style, we'd implement this as follows:

<?php

$x = 20;

if ($x % 2 === 0) {
   echo 'Divisible by 2 or 3';
}
elseif ($x % 3 === 0) {
   echo 'Divisible by 2 or 3';
}

We have an if statement to check for divisibility by 2 and then an elseif statement to check for divisibility by 3. In either case, we print the same thing.

Now using the power of ||, we can shorten this code and make it much more readable:

<?php

$x = 20;

if ($x % 2 === 0 || $x % 3 === 0) {
   echo 'Divisible by 2 or 3';
}

The || operator, as used here, simply evaluates to true if either $x % 2 === 0 or $x % 3 === 0 is met. Otherwise, it evaluates to false.

Time to move on to the logical AND operator.

The table below summarizes its semantics:

As before, let's consider an example.

Suppose we want to print 'Divisible by 2 and 3' if a given integer $x is divisible by both 2 and 3. In the typical if style, this would be done as follows:

<?php

$x = 6;

if ($x % 2 === 0) {
   if ($x % 3 === 0) {
      echo 'Divisible by 2 and 3';
   }
}

We have an if statement checking for divisbility by 2 and then an if statement nested inside it checking for divisbility by 3.

Once again, this could more succinctly be written using && as follows:

<?php

$x = 6;

if ($x % 2 === 0 && $x % 3 === 0) {
   echo 'Divisible by 2 and 3';
}

Simple.

Note that these aren't the only logical operators provided by PHP. There are a couple more such as and, or and xor. We'll cover all of them in the PHP Control Flow unit.

As we've seen in the PHP Control Flow chapter, PHP provides a shortcut to increment and decrement a variable's value. That's using the ++ and -- operators.

Now there are two kinds of increment/decrement operators as demonstrated below:

The example below demonstrates the two increment (++) operators:

<?php

$x = 0;

echo '$x: ', $x, "\n";
echo '++$x: ', ++$x, "\n";
echo '$x++: ', $x++, "\n";
echo '$x: ', $x, "\n";

Since ++ is merely a kind of assignment, it's invalid to use it on a literal value. This can be seen as follows:

<?php

10++;

Increment operators are most commonly used with counter variables i.e. variables meant to keep track of indexes in a sequence, or other counting enumerations.

A familiar example for the increment operator is that of the for loop as shown below:

<?php

$nums = [1, 2, 10, -5];

for ($i = 0; $i < count($nums); $i++) {
   echo $nums[$i], "\n";
}

Here in the third expression of the for loop's header, we use $i++. This is to increment $i after the given iteration so as to proceed closer and closer to the termination condition of the loop.

Note that it would be completely fine even if we use the prefix increment (++$x) operator here:

<?php

$nums = [1, 2, 10, -5];

for ($i = 0; $i < count($nums); ++$i) {
   echo $nums[$i], "\n";
}

When we talk about strings, we can't end the conversation without talking about the idea of concatenation.

To recap it, concatenation is the joining of two strings into one single string. In PHP, concatenation is done using the . operator.

Below shown is an example:

<?php

$end = '!';
echo 'Hello ' . 'World' . $end;