Return type declarations in PHP 7 enforce the type of value a function must return. By appending a colon and a type (e.g., : int, : string) after a function definition, developers ensure functions return expected data types, reducing bugs and improving clarity. Strict mode (declare(strict_types=1);) enforces stricter type checks but only applies to parameters, not return types. Common return types include int, string, array, void, and nullable types like ?string. However, backward compatibility and inheritance behaviors require caution when implementing return types. Overall, they enhance predictability, maintainability, and tooling support in larger projects or team environments.

When PHP 7 came out, one of the notable additions was return type declarations. In simple terms, this feature lets you specify what type of value a function should return. Before PHP 7, functions could return anything, and it was up to the developer to make sure they returned the right kind of data. Now, you can enforce that at the language level.

What Are Return Type Declarations?

Return type declarations are a way to define what kind of data a function must return. You add a colon after the function definition followed by the type — like : int, : string, or even : array.

For example:

function getAge(): int {
    return 30;
}

If someone tries to return a string from this function, PHP will throw a TypeError — unless you’ve turned off strict mode, which we’ll talk about next.

Why Use Them?

There are a few solid reasons to use return types:

• Clarity: When you see function getUser(): array, you immediately know what to expect.
• Fewer Bugs: If a function is supposed to return an integer but returns null or a string instead, PHP catches it early.
• Better Tooling: IDEs and static analyzers can give more accurate suggestions and warnings when types are clear.

It's especially helpful in larger projects or when working with teams where keeping things predictable matters.

How Does Strict Mode Affect Return Types?

PHP has a setting called strict mode, which affects how type checking works. By default, PHP is lenient. For example, if a function says it returns an int but returns a float instead, PHP will just convert the float to an int and move on — no error.

But if you enable strict mode with declare(strict_types=1);, PHP becomes much stricter. It won’t automatically convert types anymore. So returning a float where an int is expected would trigger a TypeError.

Just keep in mind:

• Strict mode only affects parameter type declarations, not return types.
• But using strict mode helps maintain consistency across your codebase.

Common Return Types You’ll See

You don’t have to limit yourself to basic types like int or string. Here are some common ones:

• int
• float
• bool
• string
• array
• object
• void (means the function doesn't return anything)
• callable
• iterable (can be either array or Traversable)

And in PHP 7.1 , you can also use nullable types by adding a question mark, like ?string, which means the function might return a string or null.

Some Gotchas to Watch For

• Don’t assume strict mode covers everything — as mentioned, it only affects parameters, not return values.
• Be careful with inheritance — if a parent class method doesn’t declare a return type, a child class can declare one.
• Backward compatibility — if you're updating old code, adding return types can break things if the function used to return different types.

So before adding return types everywhere, make sure your existing logic aligns with what you’re enforcing.

Basically, return type declarations help make your functions more predictable and easier to understand. They're not mandatory, but once you start using them, especially alongside parameter type hints and strict mode, your code becomes more robust and easier to maintain.

The above is the detailed content of What is return type declarations in PHP 7?. For more information, please follow other related articles on the PHP Chinese website!