Mastering PHP Expressions and Operators: A Comprehensive Guide

Introduction

Operators are fundamental to performing operations in PHP, such as arithmetic calculations, comparisons, logical evaluations, and more PHP offers a rich set of operators that enable developers to perform various operations on variables, combine values, and create complex expressions. Understanding these operators is crucial for writing efficient and clean PHP code. In this guide, we’ll explore the essential PHP operators, their syntax, and practical examples to help you master them.

1. Arithmetic Operators

Arithmetic operators allow you to perform mathematical calculations.

Operator	Name	Example	Result
`+`	Addition	`$a + $b`	Sum of `$a` and `$b`
`-`	Subtraction	`$a - $b`	Difference between `$a` and `$b`
`*`	Multiplication	`$a * $b`	Product of `$a` and `$b`
`/`	Division	`$a / $b`	Quotient of `$a` and `$b`
`%`	Modulus	`$a % $b`	Remainder of `$a` divided by `$b`
`**`	Exponentiation	`$a ** $b`	`$a` raised to the power of `$b`

Example:

$a = 10;
$b = 3;
echo $a + $b;   // Addition: 13
echo $a - $b;   // Subtraction: 7
echo $a * $b;   // Multiplication: 30
echo $a / $b;   // Division: 3.3333
echo $a % $b;   // Modulus (remainder): 1
echo $a ** $b;  // Exponentiation: 1000

2. Assignment Operators

Assignment operators assign values to variables.

Operator	Example	Equivalent To
`=`	`$a = $b`	Assign `$b` to `$a`
`+=`	`$a += $b`	`$a = $a + $b`
`-=`	`$a -= $b`	`$a = $a - $b`
`*=`	`$a *= $b`	`$a = $a * $b`
`/=`	`$a /= $b`	`$a = $a / $b`
`%=`	`$a %= $b`	`$a = $a % $b`

Example:

$x = 5;         // Simple assignment
$x += 3;        // Equivalent to $x = $x + 3 (8)
$x -= 2;        // Equivalent to $x = $x - 2 (6)
$x *= 2;        // Equivalent to $x = $x * 2 (12)
$x /= 4;        // Equivalent to $x = $x / 4 (3)
$x %= 2;        // Equivalent to $x = $x % 2 (1)

3. Comparison Operators

Comparison operators compare two values and return true or false.

Operator	Name	Example	Result
`==`	Equal	`$a == $b`	`true` if `$a` is equal to `$b`
`===`	Identical	`$a === $b`	`true` if `$a` is equal to `$b` and same type
`!=`	Not equal	`$a != $b`	`true` if `$a` is not equal to `$b`
`!==`	Not identical	`$a !== $b`	`true` if `$a` is not equal to `$b` or not same type
`>`	Greater than	`$a > $b`	`true` if `$a` is greater than `$b`
`<`	Less than	`$a < $b`	`true` if `$a` is less than `$b`
`>=`	Greater or equal	`$a >= $b`	`true` if `$a` is greater than or equal to `$b`
`<=`	Less or equal	`$a <= $b`	`true` if `$a` is less than or equal to `$b`

Example:

$a = 5;
$b = '5';

var_dump($a == $b);    // Loose comparison (true)
var_dump($a === $b);   // Strict comparison (false)
var_dump($a != $b);    // Not equal (false)
var_dump($a !== $b);   // Not identical (true)
var_dump($a > 3);      // Greater than (true)
var_dump($a < 10);     // Less than (true)
var_dump($a >= 5);     // Greater than or equal (true)
var_dump($a <= 4);     // Less than or equal (false)

4. Increment/Decrement Operators

Used to increase or decrease variable values by 1.

Operator	Description	Example
`++$a`	Pre-increment	Increment `$a` before using it
`$a++`	Post-increment	Use `$a`, then increment
`--$a`	Pre-decrement	Decrement `$a` before using it
`$a--`	Post-decrement	Use `$a`, then decrement

Example:

$x = 5;
echo $x++;     // Post-increment (prints 5, then becomes 6)
echo ++$x;     // Pre-increment (becomes 7, then prints 7)
echo $x--;     // Post-decrement (prints 7, then becomes 6)
echo --$x;     // Pre-decrement (becomes 5, then prints 5)

5. Logical Operators

Logical operators are used to combine conditional statements:

Operator	Name	Example	Result
`&&`	AND	`$a && $b`	`true` if both `$a` and `$b` are true
`		`	OR
`!`	NOT	`!$a`	`true` if `$a` is false

Example:

$a = true;
$b = false;

var_dump($a && $b);   // AND operator (false)
var_dump($a || $b);   // OR operator (true)
var_dump(!$a);        // NOT operator (false)
var_dump($a xor $b);  // XOR operator (true)

6. String Operators

String operators help manipulate and combine strings:

Operator	Name	Example	Result
`.`	Concatenation	`$a . $b`	Joins `$a` and `$b`
`.=`	Concatenation assignment	`$a .= $b`	Appends `$b` to `$a`

Example:

$greeting = "Hello";
$name = "World";

echo $greeting . " " . $name;  // Concatenation: "Hello World"
$greeting .= " PHP";           // Concatenation assignment: "Hello PHP"

7. Array Operators

Array operators allow you to combine and compare arrays:

Operator	Name	Example
`+`	Union	`$a + $b`
`==`	Equality	`$a == $b`
`===`	Identity	`$a === $b`

Example:

$a = ["a" => 1, "b" => 2];
$b = ["c" => 3, "d" => 4];
print_r($a + $b);

var_dump($a + $b);     // Union of arrays
var_dump($a == $b);    // Equality comparison (false)
var_dump($a === $b);   // Identity comparison (false)

8. Conditional Assignment Operators

The null coalescing and ternary operators provide concise conditional assignments:

Operator	Name	Example	Description
`?:`	Ternary	`$a = $b ?: "default"`	If `$b` is true, `$a = $b`; otherwise `$a = "default"`
`??`	Null coalescing	`$a = $b ?? "default"`	If `$b` is set, `$a = $b`; otherwise `$a = "default"`

Example:

// Ternary operator
$status = ($score > 60) ? 'Pass' : 'Fail';

// Null coalescing operator
$c = null;
$d = $c ?? "Default"; // Output: Default

$username = $_GET['user'] ?? 'guest';

Null-Safe Operator (`?->`)

Null-Safe Operator: Safely Accessing Object Properties and Methods Introduced in PHP 8.0, the null-safe operator (?->) provides a cleaner and more concise way to access object properties and methods when dealing with potentially null objects. It helps prevent "Trying to access property of non-object" errors, which are common when working with objects that might be null.

Syntax:

$object?->property;
$object?->method();
$object?->property?->property;

How It Works:

If the object is not null, the property or method is accessed as usual.
If the object is null, the expression short-circuits and returns null.

Example:

class User {
    public function getName() {
        return "John";
    }
}

$user = null;
$name = $user?->getName(); // Safe: returns null if $user is null
echo $name ?? "No user"; // Outputs: No user

$user = new User();
$name = $user?->getName(); // Safe: calls getName() if $user is not null
echo $name; // Outputs: John

// Without Null-Safe Operator
if ($user !== null) {
    echo $user->getName();
} else {
    echo null;
}

// Without Null-Safe Operator
echo $user->getName(); // Error: Trying to access method on null object

9. Type Operators

Type operators check an object's type.

class MyClass {}
$obj = new MyClass();

// instanceof checks if an object is an instance of a class
var_dump($obj instanceof MyClass);  // true

10. Bitwise Operators

For advanced use cases involving bit-level manipulations:

$a = 5;  // Binary: 101
$b = 3;  // Binary: 011

echo $a & $b;   // Bitwise AND (1)
echo $a | $b;   // Bitwise OR (7)
echo $a ^ $b;   // Bitwise XOR (6)
echo ~$a;       // Bitwise NOT (-6)
echo $a << 1;   // Left shift (10)
echo $a >> 1;   // Right shift (2)

Practice: Let's Apply What We've Learned

Create a new PHP file named "lesson-operators.php"
Write a program that demonstrates various operators:

<?php

// Arithmetic operations
$num1 = 20;
$num2 = 5;

// Calculate and display results
echo "Addition: " . ($num1 + $num2) . "\n";
echo "Subtraction: " . ($num1 - $num2) . "\n";
echo "Multiplication: " . ($num1 * $num2) . "\n";
echo "Division: " . ($num1 / $num2) . "\n";

// Comparison operations
$x = 10;
$y = "10";

var_dump($x == $y);   // Loose comparison
var_dump($x === $y);  // Strict comparison

// Logical operations
$a = true;
$b = false;

var_dump($a && $b);  // AND operation
var_dump($a || $b);  // OR operation

// String concatenation
$first = "Hello";
$second = "World";
echo $first . " " . $second;
echo PHP_EOL;

Run the file and observe the outputs

php lesson-operators.ph

PHP Operators

Experiment with different values and operators

This exercise will help reinforce your understanding of PHP operators.

Conclusion

Mastering PHP operators is essential for writing efficient and expressive code. Each operator type serves a specific purpose, from basic arithmetic to complex logical evaluations. Practice and experimentation will help you leverage these operators effectively in your PHP development journey.

Best Practices

Always use strict comparison (===) when possible
Be mindful of type juggling
Use parentheses to clarify complex expressions
Consider readability when chaining operators
Consider short-circuit evaluation when using logical operators

Performance Tip

Some operators like ++ can be slightly faster than full addition, but prioritize code readability over micro-optimizations.

Introduction

1. Arithmetic Operators

2. Assignment Operators

3. Comparison Operators

4. Increment/Decrement Operators

5. Logical Operators

6. String Operators

7. Array Operators

8. Conditional Assignment Operators

Null-Safe Operator (?->)

Syntax:

How It Works:

9. Type Operators

10. Bitwise Operators

Practice: Let's Apply What We've Learned

Conclusion

Best Practices

Performance Tip

Table of Contents

Null-Safe Operator (`?->`)