Type hinting in PHP is a feature that allows developers to specify the type of data that a function or method parameter can accept. This feature was introduced in PHP 5 and has been improved in subsequent versions.

In this article, we’ll discuss PHP type hinting in detail, including its types, syntax, usage, examples, and benefits.

Anyway, the following sections will outline the various types of type hinting in PHP with examples.

PHP Function Type Hints

Function type hints are a feature in PHP that allows developers to declare the expected data type for function parameters and return values

Using Function Type Hints for Parameters

This feature ensures functions receive expected data types. It prevents errors and improves code reliability.

To use function type hints, specify the expected data type before the parameter name in the function or method declaration. For example:

<?php 

function myFunction(string $myString, int $myInt) {
    // Function logic here
}

In the above example, the function myFunction expects two parameters, one of type string and the other of type int. If a different data type is passed to the function, PHP will throw an error.

The proper way to call this function would be as follows:

<?php 

/*An error will be displayed if any 
other data type is passed to the function.*/
myFunction( "hello", 25 );

Using Function Type Hints for Return Values

To use function type hints for return values, specify the expected data type after the function or method declaration. For example:

<?php 

function myFunction(): bool {
    // Function logic here
}

In the above example, the function myFunction should return a boolean value. If the function returns a different data type, PHP will throw an error.

Moreover, PHP has eight primitive data types that can be used in PHP type hints, as follows:

  1. bool (for boolean values)
  2. int (for integer values)
  3. float (for floating-point values)
  4. string (for string values)
  5. array (for arrays)
  6. object (for objects)

You can learn more about them from here. additionally, you can use callable as PHP type hint for example:

<?php 

function myFunction(callable $myParam): void {
    // Function code goes here
}

In this example, we have specified that the parameter $myParam should be a callable function.

PHP Type Hinting: Class and Interface

This type hinting allows you to specify the name of a class as a parameter or return type. This ensures that the parameter or return value is an instance of that class or one of its subclasses. For example:

<?php 

class MyClass {
    // ...
}

function explorer(MyClass $obj) {
    // ...
}

$obj = new MyClass();
explorer($obj); // works

$str = "hello";
explorer($str); // throws TypeError

In the example above, explorer() function takes a parameter of type MyClass. The function expects an instance of the MyClass class as an argument, and will throw a TypeError if any other data type is passed.

Let’s take an example to illustrate the same way in the Interface as well.

<?php 
interface MyInterface {
    // ...
}

class MyClass implements MyInterface {
    // ...
}

function explorer(MyInterface $obj) {
    // ...
}

$obj = new MyClass();
explorer($obj); // works

$str = "hello";
explorer($str); // throws TypeError

In this example, explorer() function takes a parameter of type MyInterface, which means it expects an instance of any class that implements the MyInterface interface. Otherwise, an error will be displayed.

PHP Type Hinting: Self and Parent Types

PHP type hinting can also be used with the self and parent keywords, which refer to the current class or the parent class, respectively. This allows developers to specify the expected class for a parameter or return value.

For example:

<?php 

class MyClass {
    public $number = 10;
    public function myFunction(self $myParam): self{
        // Function code goes here
        return $myParam;
    }
}

$obj = new MyClass();
echo $obj->myFunction($obj)->number; // 10

In this example, we have specified that the parameter $myParam should be an instance of the MyClass class and the function should return an instance of the MyClass class.

PHP Type Hinting: Union Types

Developers have the capability to indicate that a variable or parameter has the ability to accommodate multiple data types.

Prior to PHP 8.0, developers could only specify a single data type or use the mixed type hint to allow any data type.

However, with the introduction of Union Types, developers can now specify multiple types that are acceptable for a variable or parameter.

To declare a Union Type in PHP, you use the | symbol to separate each data type. For example, if you want to specify that a function parameter can accept either a string or an integer, you can use the following syntax:

<?php 

function myFunction(string|int $param) {
    // Function body
}

This function can now accept either a string or an integer as the $param argument.

It’s worth noting that Union Types are a new feature introduced in PHP 8.0, so earlier versions of PHP do not support this feature. Additionally, not all IDEs and code editors may fully support Union Types, so developers should check their development environment to ensure compatibility.

PHP Type Hinting: Mixed Types

The mixed type hint can be used in PHP to allow any data type, but it’s important to note that it doesn’t provide any information about the expected data type, which can make code harder to read and maintain. Additionally, using mixed may increase the risk of errors and unexpected behaviors.

Here’s an example of how to use mixed in PHP:

<?php 
function myFunction(mixed $param) {
    // Function body
}

This function can now accept any data type as the $param argument.

PHP Type Hinting: Nullable Types

In PHP Type Hinting, developers can utilize nullable types to indicate whether a parameter or variable is capable of accepting null as a valid value. Nullable types are useful when a parameter or variable can have a value or be empty.

To declare a nullable type in PHP, you use the ? symbol before the type hint. For example, if you want to specify that a function parameter can accept a string or null, you can use the following syntax:

<?php 
/* This function can now accept either 
a string or null as the $param argument.
*/
function myFunction(?string $param) {
    // Function body
}

Nullable types improve code clarity and reduce errors. Developers can explicitly define if null is acceptable for a parameter or variable. It’s crucial to use nullable types carefully and handle null values appropriately in the function or code block. This featured introduced in PHP 7.1.

Wrapping Up

PHP type hints provide a powerful feature for developers to specify the expected data types of variables and function parameters in their code. By using type hints, developers can improve code clarity, reduce errors, and make code easier to maintain and debug.

PHP supports scalar types such as int, float, string, and bool, as well as compound types such as array, object, and callable. In addition, PHP 8.0 introduced union types and named arguments, providing more flexibility and granularity in type hinting.

Developers can also use mixed types and nullable types to accept any data type and null values, respectively. However, it is important to use these types judiciously and only when necessary to avoid reducing the clarity and maintainability of the code.

Overall, PHP type hints are a valuable tool for PHP developers to write cleaner, more reliable, and more maintainable code.

To lean more details visit PHP manual.