New: Automatic Theme Update - When a theme update is available, you can install the latest version with a single click, directly from the theme panel. The system downloads the latest version from the tagDiv servers and automatically updates the theme' files and the native plugins so that you can focus on the content. Theme Changes New Redwood Theme. Redwood is the new Oracle user experience design language, and it is the recommended theme if you are building a new application. Nothing deprecated in JET 9 or earlier is guaranteed to work in Redwood or continue to work in later releases, so if you are migrating you must remove any deprecated API's to use Redwood.
It contains many new features and optimizations including named arguments, union types, attributes, constructor property promotion, match expression, nullsafe operator, JIT, and improvements in the type system, error handling, and consistency.
Named arguments RFC
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);- Specify only required parameters, skipping optional ones.
- Arguments are order-independent and self-documented.
Attributes RFCDoc
class PostsController
{
/**
* @Route('/api/posts/{id}', methods={'GET'})
*/
public function get($id) { /* ... */ }
}class PostsController
{
#[Route('/api/posts/{id}', methods: ['GET'])]
public function get($id) { /* ... */ }
}
Instead of PHPDoc annotations, you can now use structured metadata with PHP's native syntax.
Constructor property promotion RFCDoc
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
Less boilerplate code to define and initialize properties.
Union types RFCDoc
class Number {
/** @var int|float */
private $number;
/**
* @param float|int $number
*/
public function __construct($number) {
$this->number = $number;
}
}
new Number('NaN'); // Okclass Number {
public function __construct(
private int|float $number
) {}
}
new Number('NaN'); // TypeErrorInstead of PHPDoc annotations for a combination of types, you can use native union type declarations that are validated at runtime.
Match expression RFCDoc
switch (8.0) {
case '8.0':
$result = 'Oh no!';
break;
case 8.0:
$result = 'This is what I expected';
break;
}
echo $result;
//> Oh no!echo match (8.0) {
'8.0' => 'Oh no!',
8.0 => 'This is what I expected',
};
//> This is what I expectedThe new match is similar to switch and has the following features:
- Match is an expression, meaning its result can be stored in a variable or returned.
- Match branches only support single-line expressions and do not need a break; statement.
- Match does strict comparisons.
Nullsafe operator RFC
$country = null;
if ($session ! null) {
$user = $session->user;
if ($user ! null) {
$address = $user->getAddress();
if ($address ! null) {
$country = $address->country;
}
}
}$country = $session?->user?->getAddress()?->country;Instead of null check conditions, you can now use a chain of calls with the new nullsafe operator. When the evaluation of one element in the chain fails, the execution of the entire chain aborts and the entire chain evaluates to null.
Saner string to number comparisons RFC
When comparing to a numeric string, PHP 8 uses a number comparison. Otherwise, it converts the number to a string and uses a string comparison.
Consistent type errors for internal functions RFC
strlen([]); // Warning: strlen() expects parameter 1 to be string, array given
array_chunk([], -1); // Warning: array_chunk(): Size parameter expected to be greater than 0strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given
array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0Most of the internal functions now throw an Error exception if the validation of the parameters fails.
Just-In-Time compilation
PHP 8 introduces two JIT compilation engines. Tracing JIT, the most promising of the two, shows about 3 times better performance on synthetic benchmarks and 1.5–2 times improvement on some specific long-running applications. Typical application performance is on par with PHP 7.4.
Relative JIT contribution to PHP 8 performance
Type system and error handling improvements
- Stricter type checks for arithmetic/bitwise operators RFC
- Abstract trait method validation RFC
- Correct signatures of magic methods RFC
- Reclassified engine warnings RFC
- Fatal error for incompatible method signatures RFC
- The @ operator no longer silences fatal errors.
- Inheritance with private methods RFC
- Mixed type RFC
- Static return type RFC
- Types for internal functions Email thread
- Opaque objects instead of resources for Curl, Gd, Sockets, OpenSSL, XMLWriter, and XML extensions
Other syntax tweaks and improvements
- Allow a trailing comma in parameter lists RFC and closure use lists RFC
- Non-capturing catches RFC
- Variable Syntax Tweaks RFC
- Treat namespaced names as single token RFC
- Throw is now an expression RFC
- Allow ::class on objects RFC
New Classes, Interfaces, and Functions
- Weak Map class
- Stringable interface
- str_contains(), str_starts_with(), str_ends_with()
- token_get_all() object implementation
Better performance, better syntax, improved type safety.
For source downloads of PHP 8 please visit the downloads page. Windows binaries can be found on the PHP for Windows site. The list of changes is recorded in the ChangeLog.
8 New Themes Released June
The migration guide is available in the PHP Manual. Please consult it for a detailed list of new features and backward-incompatible changes.