PHP is widely regarded as a weakly typed language. In PHP, you need not declare the type of a variable before assigning it any value. The PHP parser tries to cast the variables into compatible type as far as possible.
For example, if one of the values passed is a string representation of a number, and the second is a numeric variable, PHP casts the string variable to numeric in order to perform the addition operation.
Automatic Type Casting in Addition
PHP converts the string to a number to perform the addition operation. Take a look at the following example −
<?php
function addition($x, $y) {
echo "First number: $x Second number: $y Addition: " . $x+$y;
}
$x="10";
$y=20;
addition($x, $y);
?>
It will produce the following output −
First number: 10 Second number: 20 Addition: 30
Error by Adding Non-Numeric String to a Number
However, if $x in the above example is a string that doesn’t hold a valid numeric representation, then you will encounter an error.
<?php
function addition($x, $y) {
echo "First number: $x Second number: $y Addition: " . $x+$y;
}
$x="Hello";
$y=20;
addition($x, $y);
?>
It will produce the following output −
PHP Fatal error: Uncaught TypeError: Unsupported operand types: string + int in hello.php:5
Type Hints
Type-hinting is supported from PHP 5.6 version onwards. It means you can explicitly state the expected type of a variable declared in your code. PHP allows you to type-hint function arguments, return values, and class properties. With this, it is possible to write more robust code.
Let us incorporate type-hinting in the addition function in the above program −
functionaddition(int$x,int$y){echo"First number: $x Second number: $y Addition: ".$x+$y;}
Note that by merely using the data types in the variable declarations doesn’t prevent the unmatched type exception raised, as PHP is a dynamically typed language. In other words, $x=”10″ and $y=20 will still result in the addition as 30, whereas $x=”Hello” makes the parser raise the error.
Example
<?php
function addition($x, $y) {
echo "First number: $x \n";
echo "Second number: $y \n";
echo "Addition: " . $x+$y . "\n\n";
}
$x=10;
$y=20;
addition($x, $y);
$x="10";
$y=20;
addition($x, $y);
$x="Hello";
$y=20;
addition($x, $y);
?>
It will produce the following output −
First number: 10 Second number: 20 Addition: 30 First number: 10 Second number: 20 Addition: 30 First number: Hello Second number: 20 PHP Fatal error: Uncaught TypeError: Unsupported operand types: string + int in hello.php:5
Using strict_types
PHP can be made to impose stricter rules for type conversion, so that “10” is not implicitly converted to 10. This can be enforced by setting strict_types directive to 1 in a declare() statement.
The declare() statement must be the first statement in the PHP code, just after the “<?php” tag.
Example
Take a look at the following example −
<?php
declare (strict_types=1);
function addition(int $x, int $y) {
echo "First number: $x Second number: $y Addition: " . $x+$y;
}
$x=10;
$y=20;
addition($x, $y);
?>
It will produce the following output −
First number: 10 Second number: 20 Addition: 30
Now, if $x is set to “10”, the implicit conversion won’t take place, resulting in the following error −
PHP Fatal error: Uncaught TypeError: addition(): Argument #1 ($x) must be of type int, string given
From PHP 7 onwards, type-hinting support has been extended for function returns to prevent unexpected return values. You can type-hint the return values by adding the intended type after the parameter list prefixed with a colon (:) symbol.
Example
Let us add a type hint to the return value of the division() function below.
<?php
declare (strict_types=1);
function division(int $x, int $y) : int {
return $x/$y;
}
$x=10;
$y=20;
$result = division($x, $y);
echo "First number: $x Second number: $y Addition: " . $result;
?>
Because the function returns 0.5, which is not of int type (that is, the type hint used for the return value of the function), the following error is displayed −
Fatal error: Uncaught TypeError: division(): Return value must be of type int, float returned in hello.php:5
Benefits of PHP Strict Typing
Here are the benefits of using the strict typing in your code −
- Strict typing improves code reliability to ensure type safety, reducing the risk of runtime errors due by incorrect data types.
- Explicit type definitions improve code readability by making it self-explanatory and understandable.
- When developers understand the different sorts of variables, it is easier to change and update the code without creating new errors.
