Why strict typing matters in PHP - The Real Reasons

The Big Idea

What if a tiny type mistake silently breaks your whole app without you noticing?

The Scenario

Imagine you are building a PHP website where users enter their age and you want to calculate discounts. Without strict typing, you might accidentally treat a text input like a number, causing unexpected results or errors.

The Problem

When PHP does not enforce strict types, it tries to guess what you mean. This can lead to bugs that are hard to find, like adding a number to a string or mixing up data types silently. It slows down debugging and can break your app in strange ways.

The Solution

Strict typing forces PHP to check that the data types match exactly. This means errors show up immediately, making your code safer and easier to understand. It helps catch mistakes early before they cause bigger problems.

Before vs After

✗ Before

$age = '25';
$discount = $age + 5; // PHP converts string to number silently

✓ After

<?php
declare(strict_types=1);
function calculateDiscount(int $age): int {
    return $age + 5;
}
calculateDiscount('25'); // Error: string given, int expected

What It Enables

Strict typing lets you write clear, reliable code that catches mistakes early and behaves exactly as you expect.

Real Life Example

In an online store, strict typing ensures that prices and quantities are always numbers, preventing wrong calculations that could cost money or confuse customers.

Key Takeaways

Manual type guessing can cause hidden bugs and confusion.

Strict typing forces clear rules, making errors obvious and easier to fix.

This leads to safer, more predictable PHP programs.

Practice

1. What is the main purpose of using declare(strict_types=1); in a PHP file?

easy

A. To disable error reporting in the script

B. To speed up the execution of PHP scripts

C. To allow automatic type conversion between variables

D. To enforce that function arguments and return values must match declared types exactly

Solution

1. Step 1: Understand the role of strict typing in PHP

   Strict typing ensures that the types of function arguments and return values are exactly as declared, preventing automatic type coercion.

2. Step 2: Analyze the effect of declare(strict_types=1);

   This declaration activates strict typing mode in the file, enforcing exact type matches and reducing bugs caused by unexpected type conversions.

3. Final Answer:

   To enforce that function arguments and return values must match declared types exactly -> Option D

4. Quick Check:

   Strict typing = enforce exact types [OK]

Hint: Strict typing means no automatic type changes allowed [OK]

Common Mistakes:

• Thinking strict typing speeds up code
• Believing it disables errors
• Assuming it allows type conversions

2. Which of the following is the correct way to enable strict typing in a PHP file?

easy

A.

B.

C.

D.

Solution

1. Step 1: Recall the syntax for enabling strict typing

   PHP uses the declare statement with strict_types=1 to enable strict typing at the start of the file.

2. Step 2: Identify the correct syntax among options

   Only uses the correct declare(strict_types=1); syntax inside PHP tags.

3. Final Answer:

   <?php declare(strict_types=1); ?> -> Option C

4. Quick Check:

   Enable strict typing = declare(strict_types=1) [OK]

Hint: Use declare(strict_types=1); at the top [OK]

Common Mistakes:

• Using incorrect function calls to enable strict typing
• Missing the declare keyword
• Placing strict_types outside PHP tags

3. What will be the output of this PHP code with strict typing enabled?

declare(strict_types=1);
function addInts(int $a, int $b): int {
    return $a + $b;
}
echo addInts(5, '10');

medium

A. TypeError

B. 510

C. 15

D. 5

Solution

1. Step 1: Understand strict typing effect on function arguments

   With strict typing enabled, PHP requires the argument types to match exactly. Passing a string '10' instead of int causes an error.

2. Step 2: Predict the behavior of the function call

   Since '10' is a string, PHP throws a TypeError instead of converting it to int automatically.

3. Final Answer:

   TypeError -> Option A

4. Quick Check:

   Strict typing + wrong type = TypeError [OK]

Hint: Strict typing rejects wrong types, causing TypeError [OK]

Common Mistakes:

• Assuming PHP converts string '10' to int automatically
• Expecting output '510' by concatenation
• Ignoring strict typing effect

4. Identify the error in this PHP code snippet with strict typing enabled:

declare(strict_types=1);
function multiply(float $x, float $y): float {
    return $x * $y;
}
echo multiply(3, '4.5');

medium

A. No error, outputs 13.5

B. TypeError because '4.5' is a string, not float

C. Syntax error due to missing semicolon

D. Warning about implicit type conversion

Solution

1. Step 1: Check argument types with strict typing

   Strict typing requires exact types. Passing '4.5' as string instead of float causes a type mismatch.

2. Step 2: Determine the error type

   PHP throws a TypeError because it does not convert string to float automatically under strict typing.

3. Final Answer:

   TypeError because '4.5' is a string, not float -> Option B

4. Quick Check:

   Strict typing + string instead of float = TypeError [OK]

Hint: Strings passed as floats cause TypeError with strict typing [OK]

Common Mistakes:

• Thinking PHP converts string '4.5' to float automatically
• Confusing TypeError with syntax error
• Expecting a warning instead of error

5. You want to write a PHP function that accepts only integers and returns their sum. Which code snippet correctly enforces strict typing and prevents accidental passing of strings or floats?

hard

A.

B.

C.

D.

Solution

1. Step 1: Check strict typing declaration

   uses declare(strict_types=1); to enable strict typing, which is required to enforce exact types.

2. Step 2: Verify function argument types

   declares the function to accept only integers using int ...$nums, enforcing all arguments to be integers.

3. Step 3: Compare other options

   lacks strict typing and type hints, allowing any type. disables strict typing. lacks type hint for arguments.

4. Final Answer:

   correctly enforces strict typing and integer-only arguments -> Option A

5. Quick Check:

   Strict typing + int type hint = safe integer sum [OK]

Hint: Use declare(strict_types=1) and int type hints for safety [OK]

Common Mistakes:

• Omitting strict_types declaration
• Not using type hints for function parameters
• Using declare(strict_types=0) which disables strict typing