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):

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:

You can follow me on Linkedin or X. I post about building my SaaS business.

Monitor 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 HTTP monitoring, query 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

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