Why strict typing matters in PHP

Introduction

Strict typing helps catch mistakes early by making sure data is the right type. It stops bugs before they happen.

When you want your program to be more reliable and avoid unexpected errors.

When working with others and you want clear rules about what kind of data functions accept.

When your program handles important data like money or user info and needs to be precise.

When debugging is hard and you want to find problems faster.

When you want your code to be easier to understand and maintain.

Syntax

PHP

<?php
declare(strict_types=1);

function add(int $a, int $b): int {
    return $a + $b;
}

echo add(5, 10);

declare(strict_types=1); turns on strict typing for the file.

Function parameters and return types are declared with types like int.

Examples

This works but PHP converts the string '3' to number 3 automatically.

PHP

<?php
// Without strict typing
function multiply($a, $b) {
    return $a * $b;
}

echo multiply('3', 4); // Works but '3' is a string

With strict typing, passing a string causes an error. Types must match exactly.

PHP

<?php
declare(strict_types=1);
function multiply(int $a, int $b): int {
    return $a * $b;
}

// echo multiply('3', 4); // Error: string given, int expected

Sample Program

This program shows how strict typing requires the argument to be a string. Passing a number would cause an error.

PHP

<?php
// Enable strict typing
declare(strict_types=1);

function greet(string $name): string {
    return "Hello, $name!";
}

// Correct usage
echo greet("Alice") . "\n";

// Uncommenting the next line will cause an error because 123 is not a string
// echo greet(123);

Important Notes

Strict typing only applies when you add declare(strict_types=1); at the top of the PHP file.

Without strict typing, PHP tries to convert types automatically, which can hide bugs.

Strict typing helps make your code safer and easier to understand.

Summary

Strict typing forces data to be the correct type, reducing bugs.

Use declare(strict_types=1); to enable it in PHP files.

It makes your code clearer and helps catch errors early.

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