Why strict typing matters in PHP - Quick Recap

Recall & Review

beginner

What is strict typing in PHP?

Strict typing means PHP checks the exact data type of variables and function arguments, preventing automatic type conversion.

beginner

How does strict typing help prevent bugs?

It stops unexpected type conversions that can cause errors, making code behavior more predictable and easier to debug.

intermediate

What happens if you pass a string to a function expecting an integer with strict typing enabled?

PHP will throw a TypeError instead of silently converting the string to an integer.

beginner

How do you enable strict typing in a PHP file?

Add declare(strict_types=1); at the very top of the PHP file before any code.

beginner

Why might strict typing improve code readability?

Because it clearly shows what types are expected, making it easier to understand what data a function works with.

What does strict typing prevent in PHP?

A Automatic type conversion

B Variable declaration

C Function calls

D Comments in code

Strict typing stops PHP from automatically converting types, enforcing exact data types.

How do you activate strict typing in a PHP file?

A Use strict_mode(); function

B Add declare(strict_types=1); at the top

C Set a config in php.ini

D Enable it in the database

You enable strict typing by adding declare(strict_types=1); at the start of the PHP file.

What error occurs if a wrong type is passed with strict typing?

A TypeError

B SyntaxError

C RuntimeWarning

D Notice

PHP throws a TypeError when a type mismatch happens with strict typing enabled.

Why is strict typing useful for debugging?

A It slows down the program

B It hides errors

C It removes comments

D It makes errors clear and early

Strict typing helps catch type errors early, making debugging easier.

Which of these is a benefit of strict typing?

A Less code needed

B Faster code execution

C More predictable code behavior

D Automatic variable creation

Strict typing makes code behavior more predictable by enforcing types.

Explain why strict typing matters in PHP and how it affects code reliability.

Think about how PHP treats data types with and without strict typing.

Describe how to enable strict typing in a PHP file and what happens if a wrong type is passed to a function.

Focus on the syntax and the error behavior.

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