Operators: Arithmetic, Comparison, and Logical

1. Arithmetic and Assignment Operators

Let's start with the most familiar category: arithmetic operators. These are the tools you'll use for any mathematical calculations in your code. Closely related are assignment operators, which provide convenient shortcuts for modifying a variable's value.

To get a clear overview of these operators, please watch the following segment from a video by Dani Krossing. It covers the basics of math operations, the order of operations (precedence), and how to use shorthand assignment operators to write cleaner code.

Let's recap the key points from the video.

Arithmetic Operators

These perform standard mathematical operations.

A crucial concept is operator precedence. By default, PHP follows standard mathematical rules (* and / are performed before + and -). You can use parentheses () to force a different order, just like in mathematics.

$result = 3 + 5 * 2; // PHP calculates 5 * 2 first, so result is 13
$result_forced = (3 + 5) * 2; // Parentheses force 3 + 5 first, so result is 16

Assignment Operators

You're already familiar with the basic assignment operator (=). PHP also provides combined operators that offer a shorthand for modifying a variable's value based on its current value.

Using these makes your code more concise and often easier to read.

$score = 100;
$score += 50; // $score is now 150

$totalPrice = 0;
$itemPrice = 15.50;
$shippingFee = 5.00;

// Add the cost of three items
$totalPrice = $itemPrice * 3;

// Add the shipping fee using a combined assignment operator
$totalPrice += $shippingFee;

echo $totalPrice; // Outputs: 51.5

2. Comparison Operators

While arithmetic operators are for calculations, comparison operators are for asking questions. They compare two values and evaluate to a boolean result: true or false. This is the foundation of decision-making in your code, which we will use heavily in the next lesson on if/else statements.

One of the most important distinctions in modern PHP is between loose comparison (==) and strict comparison (===). Getting this right can prevent subtle bugs. The following video provides an excellent explanation, including a real-world example using strpos() that highlights why strict comparison is almost always the safer choice.

To summarize the critical takeaway from the video:

• Loose Comparison (==): Checks if values are equal after performing type juggling. For example, 5 == "5" evaluates to true because PHP converts the string "5" to an integer before comparing.
• Strict Comparison (===): Checks if values are equal AND if they are of the same data type. 5 === "5" evaluates to false because one is an integer and the other is a string.

Best Practice: For professional development, you should default to using strict comparison (=== and !==). This prevents unexpected behavior from PHP's type juggling and makes your code's intent clearer and less prone to bugs.

3. Logical Operators

Logical operators are your tools for creating complex conditions. They allow you to combine the results of multiple comparison expressions. For example, you might want to check if a user is logged in AND has administrator privileges.

The main logical operators are:

• && (or and): Logical AND - true only if both sides are true.
• || (or or): Logical OR - true if at least one side is true.
• ! : Logical NOT - Inverts a boolean value (true becomes false, false becomes true).

This next video segment will show you how to combine these operators to build more expressive conditions.

The video mentions that && has a higher precedence than ||, meaning and operations are evaluated before or operations. Just like with arithmetic, you can use parentheses () to explicitly control the order.

Here is a practical code example that determines if a year is a leap year. Notice how logical operators and parentheses are used to combine multiple conditions into a single if statement.

$year = 2024;

// A year is a leap year if it is divisible by 4,
// unless it is divisible by 100 but not by 400.
if (($year % 4 == 0 && $year % 100 != 0) || ($year % 400 == 0)) {
    echo "$year is a leap year.";
} else {
    echo "$year is not a leap year.";
}

// Output: 2024 is a leap year.

4. Other Useful Operators

Finally, let's cover a few other operators that are extremely common in daily PHP development.

String Concatenation Operator

To join strings together, PHP uses the dot (.) operator.

$firstName = "Alex";
$lastName = "Jones";

// Use the dot operator to join the strings with a space
$fullName = $firstName . " " . $lastName;

echo $fullName; // Outputs: Alex Jones

There is also a combined assignment version, .=, which appends a string to an existing one.

$message = "Hello";
$message .= ", welcome to the site!";
echo $message; // Outputs: Hello, welcome to the site!

Increment and Decrement Operators

These are simple shortcuts to add or subtract 1 from a variable, which is especially useful when writing loops (a topic for a future lesson).

• ++$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.

The difference between pre- and post-increment can be subtle but important.

$apples = 5;
echo ++$apples; // Outputs 6 (increments first, then echos)

$oranges = 5;
echo $oranges++; // Outputs 5 (echos first, then increments)
echo $oranges;   // Outputs 6

Conclusion

Excellent work! You've now revisited the fundamental operators that drive the logic in any PHP application.

Key Takeaways:

• Arithmetic operators (+, -, *, /, %, **) perform mathematical calculations. Use parentheses () to control the order of operations.
• Assignment operators (=, +=, *=, etc.) are shorthands for modifying variables.
• Comparison operators (==, ===, !=, <, >) compare values and result in true or false.
• Always prefer strict comparison (=== and !==) to avoid bugs from PHP's automatic type juggling.
• Logical operators (&&, ||, !) combine boolean expressions to create complex conditions.

Now that you can create expressions that evaluate to true or false, you have the tools to make decisions. In our next lesson, we will learn how to use these expressions to control the flow of your program with if, else, and switch statements.