PHP Return Type Declarations – Scalar, Array, Object, Void & More

Introduction – Why Return Type Declarations Matter

In modern PHP development, clarity and predictability are key. With return type declarations, you can define what type of data a function is expected to return. This feature, introduced in PHP 7, enhances code readability, enables better error handling, and makes your applications easier to debug and maintain.

In this guide, you’ll learn:

• What return type declarations are
• How to declare return types for functions and methods
• Differences between strict and coercive return behavior
• Supported types and return scenarios
• Best practices and real-world examples

What Is a Return Type Declaration?

A return type declaration tells PHP what kind of value a function or method must return. It follows the parameter list and a colon (:) in the function definition.

Syntax

function functionName(parameters): returnType {
    // function body
}

Example – Return an Integer

<?php
function getAge(): int {
    return 30;
}
echo getAge(); // Outputs: 30
?>

The function is guaranteed to return an int.

Enabling Strict Mode (Optional)

PHP is coercive by default (it converts values automatically). To enable strict enforcement:

<?php
declare(strict_types=1);

Must be placed at the top of the PHP file.

Coercive vs Strict Mode in Return Types

Examples for All Supported Return Types

Return float

function getPrice(): float {
    return 199.99;
}

Return bool

function isLoggedIn(): bool {
    return true;
}

Return string

function getName(): string {
    return "Vaibhav";
}

Return array

function getItems(): array {
    return ["apple", "banana"];
}

Return object

class User {
    public $name = "Admin";
}

function getUser(): User {
    return new User();
}

Return void (PHP 7.1+)

function logAction(): void {
    echo "Logged!";
}

void means the function should not return anything.

Return ?type (Nullable Return Type – PHP 7.1+)

function getUserEmail(): ?string {
    return null;
}

Can return a string or null.

Return mixed (PHP 8.0+)

function getConfig(): mixed {
    return ["debug" => true];
}

Can return any type — use only when flexibility is required.

Return never (PHP 8.1+)

function terminate(): never {
    exit("Fatal Error");
}

Used when the function never returns (e.g., throws an exception or exits).

Real-World Example – Type-Safe API Function

declare(strict_types=1);

function getUserIdByEmail(string $email): int {
    // simulate DB query
    return 42;
}

Guarantees that the function will return only an integer — critical for database-driven apps.

Best Practices for Return Type Declarations

Summary – Recap & Next Steps

Return type declarations help you create robust and error-resistant PHP code. By clearly defining what a function will return, you enforce logic and make your code easier to understand, debug, and refactor.

Key Takeaways:

• Add : type to declare return types (int, string, array, etc.)
• Enable strict mode using declare(strict_types=1) for strict enforcement
• Use ?type for nullable returns and void for functions without returns
• Introduced in PHP 7, enhanced in PHP 7.1, 8.0, and 8.1+ with types like mixed, never
• Write safer and more predictable code, especially in large-scale applications

Real-World Relevance:
Return types are used extensively in frameworks like Laravel, Symfony, and WordPress, and are essential in building scalable, maintainable, and error-proof codebases.

Frequently Asked Questions (FAQ)

Is return type declaration mandatory in PHP?
No, it’s optional—but highly recommended for cleaner and safer code.

Can a function have multiple return types?
Yes, using union types in PHP 8+:

function fetchData(): string|false { ... }

What happens if the return type is wrong in strict mode?
PHP throws a TypeError if the return value does not match the declared type.

Can I return null from a function with string return type?
No, unless the return type is ?string.

What is the use of void return type in PHP?
Indicates the function should not return anything — helps avoid accidental return statements.