Why use declare(strict_types=1) in PHP – Fast tips

Valerio Barbera

In this tutorial, we’ll explore what declare(strict_types=1) means, why PHP developers should use it and why not, and provide examples to illustrate its importance.

This setting comes because of the loosely typed nature of PHP and the increasing demand of strictly typed features led by other popular languages like Java.

Both typing strategies (loose vs strict) have pros and cons, first of all let’s understand their meaning.

Loosely Typed Language

A loosely typed language, also known as a dynamically typed language, is a programming language where variables are not bound to a specific data type at compile-time. You don’t need to declare in advance what data type a variable will contain during the execution.

The data type of a variable is determined based on the value it holds and can change at runtime.

PHP is basically a loosely typed language, so we can write an example with it:

$a = "hello";
$a = 1; 
// No errors. The content of the variable is changed from string to int.

Loosely typed languages often allow for implicit type conversion, meaning they may automatically convert data from one type to another to facilitate operations. This behavior can lead to more flexibility but also a higher potential for functional errors.

Strictly Typed Language

A strictly typed language, also known as a statically typed language, is a programming language where variables must be explicitly declared with a specific data type at compile-time. 

Once a variable’s data type is defined, it cannot change during its lifetime. Strictly typed languages do not perform implicit type conversion, meaning operations between variables of different types typically result in a compilation error. 

We can write an example in Java:

public class CompileError {
    public static void main(String[] args) {
        int x = 15;
        x = "Valerio";
    }
}

What is declare(strict_types=1)?

declare(strict_types=1) is a directive in PHP that enforces strict type checking for function and method arguments and return values within a specific PHP file or code block. When you enable strict type checking, PHP ensures that the data types of function arguments and return values match exactly with the declared types. Exactly the same way as Java does.

Place this declaration at the very beginning of your PHP file or code block (before any other code) to enable strict typing.

Here’s the basic syntax to enable strict type checking:

<?php
declare(strict_types=1);
function speak(string $name): string 
{
    return "Hello {$name}!";
}
speak(1); // This fires the error "Uncaught TypeError"
speak("Valerio"); // This prints "Hello Valerio!"

Why Use declare(strict_types=1)?

Enforcing strict typing can significantly improve your code’s reliability in certain scenarios.

Strict typing helps prevent unexpected type-related issues that can lead to runtime errors or incorrect behavior. It ensures that you’re always working with the data types you expect.

For example, consider a function that is supposed to add two numbers:

function add($a, $b) 
{
    return $a + $b;
}
$result = add(5, '10'); // Without strict typing, this is allowed.
echo $result; // Output: 15

Without strict types, PHP would coerce the string ’10’ to an integer and produce a result that might not be what you intended. 

With declare(strict_types=1):

<?php
declare(strict_types=1);
function add(int $a, int $b) 
{
    return $a + $b;
}
$result = add(5, '10'); // Fatal error: Uncaught TypeError

With strict types enabled, PHP throws a `TypeError` and prevents the function from running, ensuring type safety.

Which strategy to choose?

Type safety is useful in various aspects of software development and can enhance the reliability and maintainability of your code. But it’s not the holy grail.

I strongly advise against mixing the two strategies. Don’t activate this language behaviour just in two or three files. It can only make more difficult to understand why an error is happening if your code runs under different rules in some parts of your application.

If you prefer strict type use it throughout the code. Otherwise modern PHP offers many other tools to enforce explicit code declaration. You have extensive support for type declaration in function arguments, return types, class properties, triple equals, and more.

Furthermore working with HTTP requests can be frustrating with strict typing enabled, since in HTTP requests everything is a string. Make your tests to avoid unnecessary headaches.

Other resources

If you find this article interesting you can find many other resources on our blog like:

Or you can explore the Fast tips articles collection.

New to Inspector? Try it for free now

Are you responsible for software development in your company? Consider trying my product Inspector to find out bugs and bottlenecks in your code automatically. Before your customers stumble onto the problem.

Inspector is usable by any IT leader who doesn’t need anything complicated. If you want effective automation, deep insights, and the ability to forward alerts and notifications into your messaging environment try Inspector for free. Register your account.

Or learn more on the website: https://inspector.dev

Related Posts

[Resolved] Integrity constraint violation – Fast tips

If you are dealing with the error: “Integrity constraint violation: Cannot add or update a child row: a foreign key constraint fails“, you are in the right article. Usually you encounter this error when you add a new column to a table and declare it as a Foreign Key.  In a SQL database, a foreign

How to monitor Guzzle Http Client – PHP Fast tips

Guzzle is a popular PHP HTTP client that makes it easy to send HTTP requests and create web service libraries. The most popular PHP frameworks provides an internal Http Client service, and they are simply a customized implementation of the Guzzle Http Client: Guzzle is widely used for two main reasons: Customization and Flexibility For

Post your Feature Requests and contribute to our product journey

I’ve recently been thinking about the best way to allow Inspector’s users to share the features they’d like to find in Inspector. Often I ask for feedback or investigate new feature requests during live chat sessions. In the first instance developers drop in a live chat asking for support. Very often these chats lead to