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.

Autofix your PHP application for free

Inspector is a Code Execution Monitoring tool specifically designed for software developers. You don’t need to install anything in the infrastructure, just install the composer package and you are ready to go.

Unlike other complex, all-in-one platforms, Inspector is super easy, and PHP friendly. You can try our Laravel or Symfony package.

If you are looking for 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

Laravel Http Client Overview and Monitoring

Laravel HTTP client was introduced starting from version 10 of the framework, and then also made available in all previous versions. It stands out as a powerful tool for making HTTP requests and handling responses from external services. This article will delve into the technical foundations of the Laravel HTTP client, its motivations, and how

Laravel Form Request and Data Validation Tutorial

In this article I will talk about Laravel Form Request to send data from your application frontend to the backend. In web applications, data is usually sent via HTML forms: the data entered by the user into the browser is sent to the server and stored in the database eventually. Laravel makes it extremely simple

Upload File in Laravel

You can upload file in Laravel using its beautiful unified API to interact with many different types of storage systems, from local disk to remote object storage like S3. As many other Laravel components you can interact with the application filesystem through the Storage Facade: Illuminate/Support/Facades/Storage This class allows you to access storage drivers called