What's new in PHP 9

PHP 9 will be the next major release of the PHP language.

The release date is still unknown, but we have hints about what's new. By looking into the PHP Wiki RFC section, we can get clues about what is coming next.

In this article, we'll cover the approved/implemented RFC (Request for Comments) and keep it updated with the latest information about PHP 9.

When is a major release necessary?

A new major release is needed whenever breaking changes in the core libraries are introduced. PHP uses the SemVer versioning scheme. 

SemVer stands for "Semantic Versioning," a versioning scheme used primarily in software development to communicate information about the changes and compatibility of a software product over time.

The purpose of SemVer is to make it easier for developers and users to understand how different versions of a software library, framework, or application relate to each other in terms of compatibility and functionality.

SemVer follows a three-part version number format: MAJOR.MINOR.PATCH. Each part carries specific information:

1. MAJOR version: This is incremented when significant changes might break backward compatibility. It indicates substantial changes in the software, and users may need to adapt their code or configurations to accommodate these changes.

2. MINOR version: This is incremented when new features are added to the software in a backward-compatible manner. It indicates that new functionality has been introduced but without breaking existing features.

3. PATCH version: This is incremented when backward-compatible bug fixes or patches are applied to the software. It indicates that issues have been addressed without introducing new features or breaking existing functionality.

What is coming in PHP 9?

I went through the PHP Wiki and checked in which RFC's PHP 9 is mentioned. These are the most notable changes coming in PHP 9. Note that nothing is confirmed yet, but it's highly likely that most of these changes will be introduced in PHP 9.

Throw exception for dynamic properties [rfc]

When writing to a non-declared property of an object, as of now, PHP will silently create a dynamic property. This is rarely done intentionally, which is why, in PHP 9, an exception will be thrown unless the class explicitly allows dynamic properties. stdClass and __get/__set are not affected by this change.

Let's look at an example:

class Car {
    public $model;
}
 
$car = new Car;
 
// Assigns declared property Car::$model.
$car->model = "BMW";
 
$car->year = 2005;
// PHP <= 8.1: Silently creates dynamic $car->year property.
// PHP    8.2: Raises deprecation warning, still creates dynamic property.
// PHP    9.0: Throws Error exception.

Explicitly allow dynamic properties

#[AllowDynamicProperties]
class Foo {}
$foo = new Foo;
 
// No deprecation warning and no exception is thrown.
$foo->bar = 1;

Fatal error when overriding an internal method with an incompatible return type [rfc]

A fatal error will be thrown when overriding internal methods with an incompatible return type.

PHP 8.x raises a deprecation notice

class MyDateTime extends DateTime
{
    public function modify(string $modifier) { return false; }
}
 
// Deprecated: Declaration of MyDateTime::modify(string $modifier) should be
// compatible with DateTime::modify(string $modifier): DateTime|false

PHP 9 will trigger a Fatal error

class MyDateTime extends DateTime
{
    public function modify(string $modifier) { return false; }
}
 
// Fatal error: Declaration of MyDateTime::modify(string $modifier) must be
// compatible with DateTime::modify(string $modifier): DateTime|false

Phase out overloaded function signatures [rfc]

What is method overloading?

Method overloading is multiple versions of the same method with the same name but different parameter types.

 Example:

class Foo {
    function sum(int $a, int $b): int
    {
        echo "int version was called\n";
        return $a + $b;
    }
    
    function sum(float $a, float $b): float
    {
        echo "float version was called\n";
        return $a + $b;
    }
}

$foo = new Foo();
$foo->sum(1, 2); // echos 'int version was called' 
$foo->sum(1.1, 2.2); // echos 'float version was called'

Most of the modern languages like Java or C# support method overloading.

Due to the significant performance hit it may have, method overloading in PHP is not going to be implemented soon, if ever.

The implemented proposal is to phase out the overloaded function signatures over the course of PHP 9.x or PHP 10.x.

array_keys()

function array_keys(array $array): array {}
function array_keys_filter(array $array, mixed $filter_value, bool $strict = false): array {}

class DatePeriod
{
    ...
 
    public function __construct(DateTimeInterface $start, DateInterval $interval, int $recurrences, int $options = 0) {}

    public function __construct(DateTimeInterface $start, DateInterval $interval, DateTimeInterface $end, int $options = 0) {}

    public function __construct(string $isostr, int $options = 0) {}
 
    ...
}

class DatePeriod
{
    ...
 
    public function __construct(DateTimeInterface $start, DateInterval $interval, DateTimeInterface|int $end, int $options = 0) {}
 
    public static function createFromISO8601String(string $specification, int $options = 0): static {}
 
    ...
}

// From undefined
$arr[] = 'some value';
$arr['doesNotExist'][] = 2;
// From false
$arr = false;
$arr[] = 2;
// From null
$arr = null;
$arr[] = 2;

$car = 'BMW';
echo 'My new car is: ' . $caar;
// Exception will be thrown, because $caar is typo and it doesn't exist.

class Test {
	public function __construct() {
		// this is illegal
		return 0;
	}
 
	// this is also illegal
	public function __destruct(): mixed {}
}
 
class Test2 {
	// this is legal (secondary vote)
	public function __construct(): void {}
 
	// this is also legal
	public function __destruct() {}
}

var_dump(str_contains("foobar", null));
// bool(true)

function my_str_contains(string $haystack, string $needle): bool {
    ...
}
var_dump(my_str_contains("foobar", null));
// TypeError: my_str_contains(): Argument #2 ($needle) must be of type string, null given