# Operators

**In PHP, operators are symbols that perform operations on one or more values (also known as operands) and return a result.** There are several different types of operators in PHP, including:

**Arithmetic operators**: perform basic arithmetic operations.**Assignment operators**: assign a value to a variable, such as the simple assignment operator.**Comparison operators**: compare two values and return a boolean result indicating whether the comparison is true or false.**Logical operators**: perform operations on boolean values and return a boolean result.

Operators are a fundamental building block of programming, and they are used to build expressions and control structures in PHP. Understanding how to use operators correctly is an essential skill for any PHP programmer.

#### What is an expression?

An expression is any piece of code that produces a value. It's like a small calculation or instruction that does something and gives you a result.

Let's go through some of these operators.

## Arithmetic Operators

Arithmetic operators are symbols used to perform basic mathematical operations such as addition, subtraction, multiplication, division, modulo division, and exponentiation. The following are the most common arithmetic operators in PHP:

### Addition

The addition operator (`+`

) adds two values together.

```
$a = 5;
$b = 2;
$c = $a + $b; // Result: 7
```

### Subtraction

The subtraction operator (`-`

) subtracts one value from another.

```
$a = 5;
$b = 2;
$c = $a - $b; // Result: 3
```

### Multiplication

The multiplication operator (`*`

) multiplies two values together.

```
$a = 5;
$b = 2;
$c = $a * $b; // Result: 10
```

### Division

The division operator (`/`

) divides one value by another.

```
$a = 5;
$b = 2;
$c = $a / $b; // Result: 2.5
```

### Modulo

Out of all the arithmetic operators, the modulo operator may feel like one of the strangest operators in PHP. The modulo division operator in PHP is represented by the percent symbol (`%`

). It performs modulo division, which returns the remainder of a division operation.

For example, if `$a`

is `5`

and `$b`

is `2`

, then `$a % $b`

would evaluate to `1`

, because `5`

divided by `2`

is `2`

with a remainder of `1`

.

The modulo operator is useful in a variety of applications, such as testing for odd or even numbers, determining the last digit of a number, or finding the next multiple of a number. For instance, you can use the modulo operator to test if a number is odd or even by checking if its remainder is `0`

or `1`

when divided by `2`

.

```
$a = 5;
$b = 2;
$c = $a % $b; // Result: 1
```

### Exponentiation

The exponentiation operator in PHP is represented by two asterisks (`**`

). It calculates the power of a number, with the first operand being the base and the second operand being the exponent.

For example, if `$base`

is `2`

and `$exponent`

is `8`

, then `$base ** $exponent`

would evaluate to `256`

, because `2`

raised to the power of `8`

is `256`

.

The exponentiation operator was introduced in PHP 7.0, so it may not be available in older versions of PHP.

```
$base = 2;
$exponent = 8;
$result = $base ** $exponent; // Result: 256
```

Arithmetic operators are used in PHP to perform simple mathematical operations and are used frequently in many PHP programs. For example, you might use arithmetic operators to calculate the total cost of an order, to determine the average score on a test, or to perform any other type of calculation that involves basic arithmetic operations.

## Assignment operators

Assignment operators in PHP are used to assign values to variables. The most commonly used assignment operator is the equal sign (`=`

), which assigns the value of the right operand to the left operand. For example:

`$a = 5;`

In this code, the value `5`

is assigned to the variable `$a`

.

In addition to the basic assignment operator, there are several compound assignment operators in PHP that combine an operation with an assignment. These operators perform the operation on the values and then assign the result to the variable on the left side. Some of the most commonly used assignment operators in PHP include:

### Addition assignment

The addition assignment (`+=`

) adds the value on the right side to the value of the variable on the left side and then assigns the result back to the left side.

In this example, `$a += 5`

is the equivalent of `$a = $a + 5`

.

```
$a = 5;
$a += 5; // Result: 10
```

### Subtraction assignment

The subtraction assignment operator (`-=`

) subtracts the value on the right side from the value of the variable on the left side, and then assigns the result back to the left side.

In this example, `$a -= 2`

is the equivalent of `$a = $a - 2`

.

```
$a = 5;
$a -= 2; // Result: 3
```

### Multiplication assignment

The multiplication assignment operator (`*=`

) multiplies the value of the variable on the left side by the value on the right side, and then assigns the result back to the left side.

In this example, `$a *= 5`

is the equivalent of `$a = $a * 5`

.

```
$a = 5;
$a *= 5; // Result: 25
```

### Division assignment

The division assignment operator (`/=`

) divides the value of the variable on the left side by the value on the right side, and then assigns the result back to the left side.

In this example, `$a /= 2`

is the equivalent of `$a = $a / 2`

.

```
$a = 5;
$a /= 2; // Result: 2.5
```

### Modulo assignment

The modulo assignment operator (`%=`

) divides the value of the variable on the left side by the value on the right side and then returns the remainder of the division operation.

In this example, `$a %= 5`

is the equivalent of `$a = $a % 2`

.

```
$a = 5;
$a %= 2; // Result: 1
```

### Exponentiation assignment

The exponentiation assignment operator (`**=`

) performs exponentiation and assigns the result to the variable on the left side.

In this example, `$a **= 5`

is the equivalent of `$a = $a ** 5`

.

```
$a = 5;
$a **= 5; // Result: 25
```

### Concatenation assignment

The concatenation assignment operator (`.=`

) performs concatenation and assigns the result to the variable on the left side.

In this example, `$b .= " world`

is the equivalent of `$b = $a . " world"`

.

```
$a = "Hello";
$b = $a . " world"; // Result: "Hello world"
```

Here's a summary of all the assignment operators.

Operator | Example | Equivalent | Operation |
---|---|---|---|

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

`-=` | `$x -= $y` | `$x = $x – $y` | Subtraction |

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

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

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

`**=` | `$z **= $y` | `$x = $x ** $y` | Exponentiation |

`.=` | `$x .= $y` | `$x = $x . $y` | Concatenation |

## Comparison operators

Comparison operators in PHP are used to compare two values and determine whether a certain condition is `true`

or `false`

. The result of a comparison is a boolean value (`true`

or `false`

).

The following are the most common comparison operators in PHP:

### Equal to

The **equal to** operator (`==`

) operator returns `true`

if the values are equal, and `false`

otherwise.

In this example, the `$a`

variable stores `true`

because `5`

and `5`

are equal to each other. The same isn't true for the `$b`

variable since `5`

is not equal to `10`

.

Lastly, the third example compares the integer `5`

with a string `"5"`

. While they're completely different data types, PHP considers them to be equal. Behind the scenes, PHP changes the data types to be the same before comparing them.

```
$a = 5 == 5; // Result: true;
$b = 5 == 10; // Result: false;
$c = 5 == "5"; // Result: true;
```

### Not equal to

The **not equal to** operator (`!=`

) returns `true`

if the values are not equal and `false`

otherwise.

Unlike before, the `$a`

variable will store `false`

even though the numbers are equal to each other. The numbers must not be the same value for a truthy value. On the other hand, the `$b`

variable will store `true`

since that's the case.

```
$a = 5 != 5; // Result: false;
$b = 5 != 10; // Result: true;
$c = 5 != "5"; // Result: false;
```

### Identical to

The **identical to** operator (`===`

) returns `true`

if the values are equal **and of the same type**, and `false`

otherwise.

The examples are the same as the equal to operator, but there's one difference than before. The `$c`

variable will store `false`

even though the values match. Since their data types are different, PHP has determined that they don't match.

The `==`

(equal to) operator and the `===`

(identical) operator are used to compare values in PHP. The difference between the two is that the `==`

operator performs a loose comparison, while the `===`

operator performs a strict comparison.

You would want to use the `==`

operator over the `===`

operator when you need to compare values of different data types, and you are okay with the type conversion. On the other hand, you would want to use the `===`

operator over the `==`

operator when you need to perform a strict comparison and do not want type conversion.

In general, it's recommended to use the `===`

operator over the `==`

operator when performing comparisons in PHP, as it provides a more secure and accurate comparison.

```
$a = 5 === 5; // Result: true;
$b = 5 === 10; // Result: false;
$c = 5 === "5"; // Result: false;
```

### Not identical to

The **not identical to** operator (`!==`

) returns `true`

if the values are not equal or not of the same type and `false`

otherwise.

```
$a = 5 !== 5; // Result: false;
$b = 5 !== 10; // Result: true;
$c = 5 !== "5"; // Result: true;
```

### Greater than

The **greater than** operator (`>`

) returns `true`

if the left value is greater than the right value and `false`

otherwise.

```
$a = 10 > 5; // Result: true;
$b = 5 > 10; // Result: false;
```

### Less than

The **less than** operator (`<`

) returns `true`

if the left value is less than the right value and `false`

otherwise.

```
$a = 5 < 10; // Result: true;
$b = 10 < 5; // Result: false;
```

### Greater than or equal to

The **greater than or equal to** operator (`>=`

) returns `true`

if the left value is greater than or equal to the right value, and `false`

otherwise.

```
$a = 10 >= 5; // Result: true;
$b = 10 >= 10; // Result: true;
$c = 5 >= 10; // Result: false;
```

### Less than or equal to

The **less than or equal to** operator (`<=`

) returns `true`

if the left value is less than or equal to the right value, and `false`

otherwise.

```
$a = 5 <= 10; // Result: true;
$b = 10 <= 10; // Result: true;
$c = 10 <= 5; // Result: false;
```

Here's a table with a summary of all the comparison operators.

Operator | Name | Description |
---|---|---|

`==` | Equal to | Return `true` if both operands are equal; otherwise, it returns `false` . |

`!=` | Not equal to | Return `true` if both operands are equal; otherwise, it returns `false` . |

`===` | Identical to | Return `true` if both operands have the same data type and equal; otherwise, it returns `false` . |

`!==` | Not identical to | Return `true` if both operands are not equal or not have the same data type; otherwise, it returns `false` . |

`>` | Greater than | Return `true` if the operand on the left is greater than the operand on the right; otherwise, it returns `false` . |

`>=` | Greater than or equal to | Return `true` if the operand on the left is greater than or equal to the operand on the right; otherwise, it returns `false` . |

`<` | Less than | Return `true` if the operand on the left is less than the operand on the right; otherwise, it returns `false` . |

`<=` | Less than or equal to | Return `true` if the operand on the left is less than or equal to the operand on the right; otherwise, it returns `false` . |

## Logical Operators

A logical operator in PHP is an operator that performs a logical operation on two or more values and returns a boolean value (`true`

or `false`

). The most common logical operators in PHP are `&&`

, `||`

, and `!`

.

Logical operators are useful in PHP because they allow us to make decisions based on multiple conditions, which is an essential part of programming. They help us write more complex and powerful code by allowing us to control the flow of execution based on different conditions.

Let's look at these operators.

### The and operator

The and operator (`&&`

) in PHP is a logical operator that is used to check if two conditions are both `true`

. If both conditions are `true`

, the operator returns `true`

, and if either one or both of the conditions are false, it returns `false`

.

#### What is a condition?

A condition in PHP is a statement that evaluates to either `true`

or `false`

. Conditions can be created using comparison operators such as `==`

(equal to), `!=`

(not equal to), `>`

(greater than), `<`

(less than), `>=`

(greater than or equal to), and `<=`

(less than or equal to). Logical operators can be used to combine multiple conditions and make more complex decisions.

In this example, the `&&`

operator checks if `$age >= 18`

and `$age <= 65`

are both `true`

. If both conditions are `true`

, the `$canWork`

variable will store `true`

.

The `&&`

operator is useful because it allows us to write code that makes decisions based on multiple conditions. For example, we could use it to check if someone is eligible for a job based on their age, education, and work experience. By combining multiple conditions with the `&&`

operator, we can write more sophisticated and powerful code.

```
$age = 20;
// Result: true;
$canWork = $age >= 18 && $age <= 65;
```

### The or operator

The or operator (`||`

) in PHP is the logical "or" operator. It is used to combine two conditions and returns `true`

if at least one of the conditions is `true`

.

In this code, the condition `$isRaining || $isSnowing`

is checking if either `$isRaining`

or `$isSnowing`

is `true`

. If either of them is `true`

, the `$isWeatherBad`

variable gets set to `true`

.

The `||`

operator is useful in situations where multiple conditions need to be checked and the program should take action if any of them is `true`

. It allows you to write concise and readable code, as you can check multiple conditions with a single line of code.

```
$isRaining = true;
$isSnowing = false;
// Result: true
$isWeatherBad = $isRaining || $isSnowing;
```

### The not operator

The `!`

operator in PHP is the logical "not" operator. It is used to negate or reverse the value of a boolean expression. It returns `true`

if the expression is `false`

, and `false`

if the expression is `true`

.

In this code, the condition `!$isRaining`

is checking if `$isRaining`

is `false`

. If it is false, the `$isWeatherGood`

variable will be set to `true`

. The `!`

operator is useful in situations where you want to check if a condition is `false`

, or you want to negate the value of a boolean expression.

```
$isRaining = false;
$isWeatherGood = !$isRaining; // Result: true
$isSnowing = true;
$isWeatherGood = !$isSnowing; // Result: false
```

### Short-circuiting

Short-circuiting in PHP refers to a feature of the `&&`

operator that stops evaluating its expressions as soon as it can determine the overall result of the operation. For example, consider the following code:

```
$debugMode = false;
$debugMode && print("Debugging Code");
```

In this code, the condition `$debugMode && print("Debugging Code");`

checks if the `$debugMode`

variable is `true`

. However, since this variable is `false`

, the second condition is **never** evaluated. Because we already know the overall result will be `false`

. The PHP interpreter takes advantage of this fact and stops evaluating $b as soon as it knows the result.

#### What is the print function?

The `print`

function is an alternative solution to the `echo`

keyword. It'll output content onto the page similar to the `echo`

keyword.

If we were to set the `$debugMode`

variable to `true`

, the reverse would occur. Since it's `true`

, the `print`

function gets executed and the message appears on the screen.

```
$debugMode = true;
$debugMode && print("Debugging mode turned on");
```

Short-circuiting helps to improve the performance of PHP code by avoiding unnecessary calculations and evaluations. In some cases, it can also help to prevent errors or unexpected results by avoiding the evaluation of expressions that would cause errors or have side effects.

## Key takeaways

- Arithmetic operators perform basic arithmetic operations.
- Assignment operators assign a value to a variable, such as the simple assignment operator.
- Comparison operators compare two values and return a boolean result indicating whether the comparison is true or false.
- Logical operators perform operations on boolean values and return a boolean result.