Why strict typing matters in PHP - See It in Action

Why strict typing matters

📖 Scenario: Imagine you are building a simple calculator that adds two numbers. Sometimes, the numbers might come as strings, and sometimes as integers. Without strict typing, mistakes can happen silently, causing wrong results.

🎯 Goal: You will create a PHP script that shows how strict typing helps catch errors early by enforcing the types of inputs to a function.

📋 What You'll Learn

Create a function with strict typing enabled

Define a function that adds two integers

Try calling the function with a string and an integer

Observe the error caused by strict typing

💡 Why This Matters

🌍 Real World

Strict typing is important in real-world PHP projects to avoid bugs caused by unexpected data types, especially when working with user input or external data.

💼 Career

Many PHP jobs require writing reliable and maintainable code. Understanding strict typing helps you write safer functions and avoid common errors.

1

Enable strict typing and create the add function

Write the first line declare(strict_types=1); to enable strict typing. Then create a function called add that takes two integer parameters int $a and int $b and returns their sum as an integer.

PHP

<?php
declare(strict_types=1);

function add(int $a, int $b): int {
    // Your code here
}

Hint

Start your PHP file with declare(strict_types=1); to turn on strict typing. Then define the function with int type hints for parameters and return type.

2

Call the add function with integer arguments

Call the add function with two integers: 5 and 10. Store the result in a variable called $result.

PHP

<?php
declare(strict_types=1);

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

// Your code here

Hint

Call the function with two numbers and save the answer in $result.

3

Call the add function with a string and an integer

Call the add function with a string '5' and an integer 10. Store the result in a variable called $result2.

PHP

<?php
declare(strict_types=1);

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

$result = add(5, 10);

// Your code here

Hint

Try passing a string instead of an integer to see how strict typing stops this.

4

Print the results

Print the variables $result and $result2 using echo statements, each on a new line.

PHP

<?php
declare(strict_types=1);

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

$result = add(5, 10);

$result2 = add('5', 10);

// Your code here

Hint

Print both results. The first will show 15. The second will cause a TypeError because of strict typing.

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