Arithmetic operators in PHP - Deep Dive

Overview - Arithmetic operators

What is it?

Arithmetic operators are symbols that perform basic math operations like adding, subtracting, multiplying, and dividing numbers. In PHP, these operators let you calculate values and store or display the results. They work with numbers and sometimes with variables holding numbers. Understanding them helps you do math in your programs easily.

Why it matters

Without arithmetic operators, computers would not be able to perform simple calculations automatically. This would make tasks like adding prices, calculating totals, or measuring time impossible to automate. Arithmetic operators solve the problem of doing math quickly and accurately in code, saving time and reducing errors compared to manual calculation.

Where it fits

Before learning arithmetic operators, you should know about variables and basic PHP syntax. After mastering arithmetic operators, you can learn about more complex expressions, functions, and control structures that use these calculations to make decisions.

Mental Model

Core Idea

Arithmetic operators are like math tools that take numbers and combine or change them to produce new numbers.

Think of it like...

Think of arithmetic operators as kitchen tools: addition is like mixing ingredients, subtraction is like removing some from a bowl, multiplication is like making multiple batches, and division is like sharing a cake evenly among friends.

  Numbers and variables
       │
       ▼
┌───────────────┐
│ Arithmetic    │
│ Operators     │
│ +  -  *  / %  │
└───────────────┘
       │
       ▼
  Result (new number)

Build-Up - 7 Steps

1

Foundation

Basic arithmetic operators in PHP

Concept: Introduce the main arithmetic operators and their symbols.

$a = 10; $b = 3; $sum = $a + $b; // 13 $difference = $a - $b; // 7 $product = $a * $b; // 30 $quotient = $a / $b; // 3.3333 $modulus = $a % $b; // 1 (remainder) // These operators work directly on numbers or variables holding numbers.

Result

Variables hold the results of each arithmetic operation as expected.

Understanding these basic operators is essential because they form the foundation of all numeric calculations in PHP.

2

Foundation

Using arithmetic with variables

Concept: Show how arithmetic operators work with variables and how results can be stored.

$x = 5; $y = 2; $z = $x + $y; // 7 $x = $x * $y; // $x becomes 10 // Variables can change value after arithmetic operations.

Result

Variables update or store new values after calculations.

Knowing that variables can hold results and be updated allows dynamic calculations in programs.

3

Intermediate

Operator precedence and parentheses

🤔Before reading on: do you think 2 + 3 * 4 equals 20 or 14? Commit to your answer.

Concept: Explain how PHP decides which operations to do first using precedence and how parentheses change that order.

$result1 = 2 + 3 * 4; // 14 because * is done before + $result2 = (2 + 3) * 4; // 20 because parentheses force addition first // Operator precedence means multiplication and division happen before addition and subtraction unless parentheses say otherwise.

Result

Calculations follow rules that affect the final answer depending on operator order.

Understanding precedence prevents bugs where calculations give unexpected results.

4

Intermediate

Modulus operator and its use

🤔Before reading on: does 10 % 3 equal 1 or 3? Commit to your answer.

Concept: Introduce the modulus operator (%) which gives the remainder after division.

$a = 10; $b = 3; $remainder = $a % $b; // 1 because 10 divided by 3 leaves remainder 1 // Modulus is useful for checking if a number is even or odd, or for cycling through values.

Result

You get the remainder of division, not the quotient.

Knowing modulus helps solve problems involving cycles, divisibility, and patterns.

5

Intermediate

Increment and decrement operators

🤔Before reading on: does $x++ add 1 before or after using $x? Commit to your answer.

Concept: Explain the shorthand operators ++ and -- that add or subtract 1 from a variable.

$x = 5; $x++; // $x becomes 6 (post-increment) ++$x; // $x becomes 7 (pre-increment) $y = $x++ + 2; // $y is 7, $x becomes 8 after // These operators are shortcuts for adding or subtracting one and have subtle timing differences.

Result

Variables increase or decrease by one, sometimes before or after use.

Understanding pre- and post-increment avoids subtle bugs in loops and calculations.

6

Advanced

Type juggling with arithmetic operators

🤔Before reading on: does PHP convert strings to numbers automatically in math? Commit to your answer.

Concept: Show how PHP automatically converts strings to numbers when using arithmetic operators and what can go wrong.

$a = '5'; $b = '3 apples'; $sum = $a + $b; // 8 because PHP converts strings to numbers ignoring text after digits $c = 'hello'; $d = 2; $result = $c * $d; // 0 because 'hello' converts to 0 // PHP tries to be flexible but this can cause unexpected results if strings are not numeric.

Result

Arithmetic operators work on strings by converting them to numbers, sometimes silently.

Knowing PHP's type juggling helps prevent bugs when mixing strings and numbers in calculations.

7

Expert

Operator overloading and custom behavior

🤔Before reading on: can you change how + works on objects in PHP? Commit to your answer.

Concept: Discuss that PHP does not support operator overloading for arithmetic operators on objects, unlike some languages, and how this affects design.

In PHP, arithmetic operators only work on numbers and strings convertible to numbers. You cannot define custom behavior for + or * on objects. Instead, you create methods like add() or multiply() inside classes. This design choice keeps PHP simple but limits operator flexibility. Example: class Number { public $value; public function __construct($v) { $this->value = $v; } public function add(Number $n) { return new Number($this->value + $n->value); } } // $a + $b is not allowed if $a and $b are Number objects.

Result

Operators behave consistently but you must use methods for custom math on objects.

Understanding PHP's lack of operator overloading clarifies how to design numeric classes and avoid confusion.

Under the Hood

When PHP encounters an arithmetic operator, it evaluates the operands first, converting them to numbers if needed. Then it performs the math operation at the CPU level using machine instructions. The result is stored back in memory as a number type. PHP's engine manages this process efficiently, handling type conversions automatically to simplify coding.

Why designed this way?

PHP was designed to be easy for beginners and flexible for web development. Automatic type juggling and fixed operator behavior reduce complexity and errors. Operator overloading was avoided to keep the language simple and maintain performance, especially since PHP is often used for quick scripting rather than complex numeric computations.

┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│   Operand 1   │ --> │ Type Conversion│ --> │ Numeric Value │
└───────────────┘     └───────────────┘     └───────────────┘
         │                                         │
         │                                         ▼
┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│   Operand 2   │ --> │ Type Conversion│ --> │ Numeric Value │
└───────────────┘     └───────────────┘     └───────────────┘
         │                                         │
         └─────────────────────────────┬───────────┘
                                       ▼
                             ┌───────────────────┐
                             │ Arithmetic Engine │
                             │ (CPU instructions)│
                             └───────────────────┘
                                       │
                                       ▼
                             ┌───────────────────┐
                             │ Result stored in  │
                             │ memory as number  │
                             └───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 5 + '10 apples' equal 15 or cause an error? Commit to your answer.

Common Belief: People often think adding a number and a string with text causes an error.

Reality: PHP converts the string to a number by reading digits until non-digit characters, so 5 + '10 apples' equals 15.

Why it matters: Assuming errors happen can cause unnecessary checks or confusion; knowing this helps write simpler code but also warns to validate inputs.

Quick: Does $x++ increase $x before or after its value is used? Commit to your answer.

Common Belief: Many believe $x++ always increases $x before using it.

Reality: $x++ uses the current value first, then increases $x after (post-increment). ++$x increases before use (pre-increment).

Why it matters: Misunderstanding this causes bugs in loops and calculations where timing of increment matters.

Quick: Can you use + to add two objects in PHP? Commit to your answer.

Common Belief: Some think PHP allows adding objects with + operator if they represent numbers.

Reality: PHP does not support operator overloading; + works only on numbers and numeric strings, not objects.

Why it matters: Expecting operator overloading leads to errors and confusion; you must use methods for object math.

Quick: Does 10 / 3 always give an integer 3? Commit to your answer.

Common Belief: People often think division returns an integer by default.

Reality: Division returns a float (decimal) result in PHP, so 10 / 3 is 3.3333, not 3.

Why it matters: Assuming integer division can cause wrong calculations and bugs in financial or measurement code.

Expert Zone

1

PHP's automatic type juggling can silently convert unexpected strings to zero, causing subtle bugs in calculations.

2

The difference between pre-increment (++$x) and post-increment ($x++) is crucial in expressions and loop conditions.

3

Modulo operator (%) works only with integers; using it with floats can lead to unexpected results or warnings.

When NOT to use

Arithmetic operators are not suitable for complex number math, big integers beyond PHP's limits, or custom numeric types. In those cases, use specialized libraries like BCMath or GMP, or define classes with methods for math operations.

Production Patterns

In real-world PHP applications, arithmetic operators are used for calculations like totals, discounts, counters, and pagination. Experts carefully handle type conversions and use explicit casting to avoid bugs. Increment operators are common in loops, and modulus is used for tasks like alternating styles or checking divisibility.

Connections

Type conversion

Arithmetic operators rely on automatic type conversion to work with different data types.

Understanding how PHP converts types helps predict how arithmetic operations behave with strings and numbers.

Control structures

Arithmetic operators often appear inside loops and conditionals to control program flow.

Knowing arithmetic operators well enables writing effective loops and decisions based on numeric conditions.

Basic algebra

Arithmetic operators implement the fundamental operations of algebra in programming.

Recognizing this connection helps learners apply math knowledge directly to coding problems.

Common Pitfalls

#1 Assuming string concatenation uses + operator

Wrong approach:

$result = 'Hello' + 'World'; // expects 'HelloWorld'

Correct approach:

$result = 'Hello' . 'World'; // correct string concatenation

Root cause:

Confusing + (arithmetic addition) with . (string concatenation) in PHP.

#2 Using division expecting integer result

Wrong approach:

$result = 10 / 3; // expects 3

Correct approach:

$result = intdiv(10, 3); // returns 3 as integer division

Root cause:

Not knowing PHP division returns float, so intdiv() is needed for integer division.

#3 Using modulus with floats

Wrong approach:

$result = 10.5 % 3; // causes warning or unexpected result

Correct approach:

$result = fmod(10.5, 3); // correct float modulus

Root cause:

Modulus operator % only works with integers; floats require fmod() function.

Key Takeaways

Arithmetic operators in PHP perform basic math like addition, subtraction, multiplication, division, and modulus on numbers and numeric strings.

Operator precedence and parentheses control the order of calculations, which affects results.

PHP automatically converts strings to numbers in arithmetic, which can cause unexpected behavior if not understood.

Increment and decrement operators have pre- and post- forms that differ in timing of the change.

PHP does not support operator overloading, so arithmetic operators cannot be customized for objects.