# PHP Operators

In this article, I show you how to manipulate and perform operations on variables and values using PHP Operators.

## What are Operators in PHP?

Operators are the symbols you use to tell the PHP processor what actions to perform. Another way to phrase it is,operators perform actions on operands and they modify values of input.

Example, in the equation **“5 + 6”**, the **5** and the **6** are both **operands**, and the **+** is the **operator**.

There are three types of operators:

- Unary – Unary operators take just one operand
- Binary – Binary operators take two operands
- Ternary – Ternary operator takes three operands

PHP divides the operators in the following groups:

- Arithmetic operators
- Assignment operators
- Comparison operators
- Increment/Decrement operators
- Logical operators
- String operators
- Array operators
- PHP Spaceship Operator New in PHP 7
- Conditional assignment operators
- Operator Precedence

## PHP Arithmetic Operators

PHP Arithmetic Operators are used with numbers to perform mathematical operations.

There are 4 operators that you’re most likely familiar with which are addition, subtraction, multiplication and division. Then there’s the modulus operator which provides you the remainder from dividing two operands.

Example: 5 divided by 2. The number 2 goes into 5 only 2 times and then 1 is the remainder which is what using the modulus operator would return.

There’s also the Exponentiation (power) operator which is used to raise a base number to an exponent.

Operator | Description | Example | Result |
---|---|---|---|

+ | Addition | $x + $y | Sum of $x and $y |

– | Subtraction | $x – $y | Difference of $x and $y |

* | Multiplication | $x * $y | Product of $x and $y |

/ | Division | $x / $y | Quotient of $x and $y |

% | Modulus | $x % $y | Remainder of $x divided by $y |

** | Exponentiation | $x ** $y | Result of raising $x to the $y’th power |

```
<?php
$x = 50;
$y = 6;
echo $x + $y . "\n"; // outputs: 56
echo $x - $y . "\n"; // outputs: 44
echo $x * $y . "\n"; // outputs: 300
echo $x / $y . "\n"; // outputs: 8.3333333333333
echo $x % $y . "\n"; // outputs: 2
echo 7 ** 7 . "\n"; // outputs: 823543
echo $x ** $y . "\n"; // outputs 15625000000
?>
```

## PHP Assignment Operators

PHP Assignment Operators are used to assign values to variables using what you might think of as the equal sign **=**, in PHP is the Assignment Operator.

What this means is the Operand on the left of the **Assignment Operator =** gets assigned the value of what’s on the right of the **Assignment Operator =** as described below.

Operator | Description | Example | Same As |
---|---|---|---|

= | x gets set to the value of the expression y on the right | $x = $y | $x = $y |

+= | Addition | $x += $y | $x = $x + $y |

-= | Subtractraction | $x -= $y | $x = $x – $y |

*= | Multiplication | $x *= $y | $x = $x * $y |

/= | Division | $x /= $y | $x = $x / $y |

%= | Modulus | $x %= $y | $x = $x % $y |

```
<?php
$x = 30; // the value 30 is represented by the variable $x
echo $x . "\n"; // Outputs: 30
$x = 40; // the value 40 is represented by the variable $x
$x += 20; // Shorthand Unary Operator
echo $x . "\n"; // Outputs: 60
$x = 80; // the value 80 is represented by the variable $x
$x -= 30; // Shorthand Unary Operator
echo $x . "\n"; // Outputs: 50
$x = 3; // the value 3 is represented by the variable $x
$x *= 20; // Shorthand Unary Operator
echo $x . "\n"; // Outputs: 60
$x = 25; // the value 25 is represented by the variable $x
$x /= 5; // Shorthand Unary Operator
echo $x . "\n"; // Outputs: 5
$x = 70; // the value 70 is represented by the variable $x
$x %= 8; // Shorthand Unary Operator
echo $x . "\n"; // Outputs: 6
?>
```

## PHP Comparison Operators

PHP Comparison Operators are used to compare two values in a Boolean fashion.

Operator | Name | Example | Result |
---|---|---|---|

== | Equal | $x == $y | True if $x is equal to $y |

=== | Identical | $x === $y | True if $x is equal to $y, and they are of the same type |

!= | Not equal | $x != $y | True if $x is not equal to $y |

<> | Not equal | $x <> $y | True if $x is not equal to $y |

!== | Not identical | $x !== $y | True if $x is not equal to $y, or they are not of the same type |

< | Less than | $x < $y | True if $x is less than $y |

> | Greater than | $x > $y | True if $x is greater than $y |

>= | Greater than or equal to | $x >= $y | True if $x is greater than or equal to $y |

<= | Less than or equal to | $x <= $y | True if $x is less than or equal to $y |

```
<?php
$x = 70;
$y = 60;
$z = "70";
// var_dump() is a PHP function that displays information about one or more expressions.
var_dump( $x == $z ); // Outputs: boolean true
var_dump( $x === $z ); // Outputs: boolean false
var_dump( $x != $y ); // Outputs: boolean true
var_dump( $x !== $z ); // Outputs: boolean true
var_dump( $x < $y ); // Outputs: boolean false
var_dump( $x > $y ); // Outputs: boolean true
var_dump( $x <= $y ); // Outputs: boolean false
var_dump( $x >= $y ); // Outputs: boolean true
echo "\n";
// real world example.
$age = 20;
if ( $age >= 21 ) {
echo "You are considered an adult and can do adult type activities. \n";
} else {
echo "You are not considered an adult and might be limited on the type of activities you can do. \n";
}
?>
```

## PHP Incrementing and Decrementing Operators

The increment/decrement operators are used to increment/decrement a variable’s value.

Operator | Name | Effect |
---|---|---|

`++$x` | Pre-increment | Increments $x by one, then returns $x |

`$x++` | Post-increment | Returns $x, then increments $x by one |

`--$x` | Pre-decrement | Decrements $x by one, then returns $x |

`$x--` | Post-decrement | Returns $x, then decrements $x by one |

```
<?php
$a = 10;
echo ++$a; // Outputs: 11
echo "\n";
echo $a; // Outputs: 11
echo "\n";
$b = 10;
echo $b++; // Outputs: 10
echo "\n";
echo $b; // Outputs: 11
echo "\n";
$c = 10;
echo --$c; // Outputs: 9
echo "\n";
echo $c; // Outputs: 9
echo "\n";
$d = 10;
echo $d--; // Outputs: 10
echo "\n";
echo $d; // Outputs: 9
echo "\n";
?>
```

## PHP Logical Operators

Logical operators are used with conditional statements and comparison operators to determine what code should be run based on the result of the check.

Operator | Name | Example | Result |
---|---|---|---|

`and` | And | `$x and $y` | True if both $x and $y are true |

`or` | Or | `$x or $y` | True if either $x or $y is true |

`xor` | Xor | `$x xor $y` | True if either $x or $y is true, but not both |

`&&` | And | `$x && $y` | True if both $x and $y are true |

`||` | Or | `$x || $y` | True if either $x or $y is true |

`!` | Not | `!$x` | True if $x is not true |

```
<?php
$x = 60;
$y = 40;
if ($x == 60 and $y == 40) {
echo '$x is equal to 60 and $y is equal to 40.' . "\n";
} else {
echo "Sorry, they both need to match \n";
}
if ($x == 60 && $y == 2) {
echo "Both are true \n";
} else {
echo "Both need to be true. \n";
}
if ($x == 60 or $y == 30) {
echo '$x is equal to 60 or $y is equal to 30.' . "\n";
}
if ($x == 60 || $y == 30) {
echo '$x is equal to 60 or $y is equal to 30.' . "\n";
}
if ($x == 60 xor $y == 10) {
echo "True if either is true but not both. \n";
}
if ($x !== 55) {
echo 'True if $x is not true' . "\n";
}
?>
```

## PHP String Operators

PHP has Two Operators that are specifically designed for strings.

**Concatenation Operator**(**.**) – the period symbol is used to combine both the right and left arguments.**Concatenation Assignment Operator**(**.=**) – the period and equals symbols are used together to append the argument on the right to the argument on the left.

Operator | Description | Example | Result |
---|---|---|---|

`.` | Concatenation | `$a . $b` | Concatenation of $a and $b |

`.=` | Concatenation assignment | `$a .= $b` | Appends $b to $a |

```
<?php
$x = "Hello";
$y = " World!";
echo $x . $y; // Outputs: Hello World!
// the newline character is used for the terminal or viewing page source.
echo "\n";
// use the <br> tag instead of the \n character for use in the browser. Just uncomment the line below
// echo '<br>';
$x .= $y;
echo $x; // Outputs: Hello World!
echo "\n";
// Reset the $x and $y variables
$x = "Hello";
$y = " World!";
echo $x .= $y; // Outputs: Hello World!
echo "\n";
?>
```

## PHP Array Operators

The array operators are used to compare arrays:

Operator | Name | Example | Result |
---|---|---|---|

`+` | Union | `$x + $y` | Union of $x and $y |

`==` | Equality | `$x == $y` | True if $x and $y have the same key/value pairs |

`===` | Identity | `$x === $y` | True if $x and $y have the same key/value pairs in the same order and of the same types |

`!=` | Inequality | `$x != $y` | True if $x is not equal to $y |

`<>` | Inequality | `$x <> $y` | True if $x is not equal to $y |

`!==` | Non-identity | `$x !== $y` | True if $x is not identical to $y |

Checkout the Code example below:

```
<?php
$x = array( "a" => "Red", "b" => "Green", "c" => "Blue" );
$y = array( "u" => "Yellow", "v" => "Orange", "w" => "Pink" );
$z = $x + $y; // Union of $x and $y
var_dump( $z );
var_dump( $x == $y ); // Outputs: boolean false
var_dump( $x === $y ); // Outputs: boolean false
var_dump( $x != $y ); // Outputs: boolean true
var_dump( $x <> $y ); // Outputs: boolean true
var_dump( $x !== $y ); // Outputs: boolean true
?>
```

## PHP Spaceship Operator New in PHP 7

PHP 7 introduced the spaceship operator (`<=>`

) which can be used for comparing two expressions. It’s also known as combined comparison operator.

The Spaceship Operator returns `-1`

if $a < $b, `0`

if $a is equal $b, `1`

if $a > $b.

Checkout the Table Below:

Spaceship Operator `<=>` | Equivalent To |
---|---|

`($x <=> $y) === -1` | `$x < $y` |

`($x <=> $y) === -1 || ($x <=> $y) === 0` | `$x <= $y` |

`($x <=> $y) === 0` | `$x == $y` |

`($x <=> $y) !== 0` | `$x != $y` |

`($x <=> $y) === 1 || ($x <=> $y) === 0` | `$x >= $y` |

`($x <=> $y) === 1` | `$x > $y` |

Checkout the example code below:

```
<?php
// Comparing Integers
echo 1 <=> 1; // Outputs: 0
echo "\n";
echo 1 <=> 2; // Outputs: -1
echo "\n";
echo 2 <=> 1; // Outputs: 1
echo "\n";
// Comparing Floats
echo 1.5 <=> 1.5; // Outputs: 0
echo "\n";
echo 1.5 <=> 2.5; // Outputs: -1
echo "\n";
echo 2.5 <=> 1.5; // Outputs: 1
echo "\n";
// Comparing Strings
echo "x" <=> "x"; // Outputs: 0
echo "\n";
echo "x" <=> "y"; // Outputs: -1
echo "\n";
echo "y" <=> "x"; // Outputs: 1
?>
```

## PHP Conditional Assignment Operators

The PHP conditional assignment operators are used to set a value depending on conditions:

Operator | Name | Example | Result |
---|---|---|---|

`?:` | Ternary | `$x = expr1 ? expr2 : expr3` | Returns the value of $x. The value of $x is expr2 if expr1 = TRUE. The value of $x is expr3 if expr1 = FALSE |

`??` | Null coalescing | `$x = expr1 ?? expr2` | Returns the value of $x. The value of $x is expr1 if expr1 exists, and is not NULL. If expr1 does not exist, or is NULL, the value of $x is expr2. Introduced in PHP 7 |

Checkout the example code below:

```
<?php
$var = 5;
// Ternary operator example
$var2 = $var > 2 ? 'yes' : 'no'; // returns yes
echo $var2;
?>
```

Below is an example if you were attempting to retrieve a value using Get or Post from a form and database.

We try out **Null Coalescing** and then **Ternary Operator**.

```
<?php
// Fetches the value of $_GET['user']
// and returns 'nobody'if it doesn't exist.
// Null Coalescing example
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
// Ternary operator example
$username = isset( $_GET['user'] ) ? $_GET['user'] : 'nobody';
// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>
```

## Let’s try various conditional examples

### if isset else example.

```
<?php
$name1 = 'Jay';
if ( isset( $name1 ) ) {
echo $name1;
} else {
echo '$name1 variable not set';
}
?>
```

**Output from above: Jay**

### Using the ternary operator to achieve the same result.

```
<?php
$name2 = 'Jay';
echo $namecheck = isset( $name2 ) ? $name2 : '$name2 variable not set';
?>
```

**Output from above: Jay**

### Use Null coalescing to achieve the same result.

```
<?php
$name3 = 'Jay';
echo $namechk = $name3 ?? '$name3 variable not set';
?>
```

**Output from above: Jay**

### This operator can also be chained (with right-associative semantics):

```
<?php
$example1 = null;
$example2 = null;
echo $output = $example1 ?? $example2 ?? '$example1 and $example2 are null';
?>
```

**Output from above: $example1 and $example2 are null**

### Which is the same as:

```
<?php
$example1 = null;
$example2 = null;
if ( isset( $example1 ) ) {
echo $example1;
} elseif ( isset( $example2 ) ) {
echo $example2;
} else {
echo '$example1 and $example2 are null';
}
?>
```

**Output from above: $example1 and $example2 are null**

## PHP Operator Precedence

Operator Precedence is based on **PEMDAS**:

- Parenthesis
- Exponents
- Multiplication
- Division
- Addition
- Subtraction

For example, * 5 + 4 * 2 = 13 not 18*. If you want to force a certain precedence, you would wrap your equation in parenthesis like so:

**(5 + 4) * 2 = 18 not 13**```
<?php
echo 5 + 4 * 2; // 13
echo '<br>';
echo (5 + 4) * 2; // 18
?>
```

## Operator Precedence Table

Associativity | Operators | Additional Info |
---|---|---|

non-associative | clonenew | clone and new |

right | ** | arithmetic |

right | ++—~(int)(float)(string)(array)(object)(bool)@ | types and increment/decrement |

non-associative | instanceof | types |

right | ! | logical |

left | */% | arithmetic |

left | +–. | arithmetic and string |

left | <<>> | bitwise |

non-associative | <<=>>= | comparison |

non-associative | ==!====!==<><=> | comparison |

left | & | bitwise and references |

left | ^ | bitwise |

left | | | bitwise |

left | && | logical |

left | || | logical |

right | ?? | null coalescing |

left | ? : | ternary |

right | =+=-=*=**=/=.=%=&=|=^=<<=>>= | assignment |

right | yield from | yield from |

right | yield | yield |

left | and | logical |

left | xor | logical |

left | or | logical |

## PHP Operators Recap

PHP Operators include:

- Arithmetic operators
- Assignment operators
- Comparison operators
- Increment and Decrement operators
- Logical operators
- String operators
- Array operators
- Spaceship Operator
- Conditional Assignment operators

PHP Operator Precedence follows PEMDAS:

- Parenthesis
- Exponents
- Multiplication
- Division
- Addition
- Subtraction

Hopefully this tutorial helped you understand PHP Operators.