What's new in PHP 8?

The JIT compiler

The JIT compiler (Just-In-Time compiler) introduced in PHP 8 is a groundbreaking addition to the interpreter, aimed at enhancing application performance. Here’s a more detailed look at how it works and the benefits it offers.

How JIT Works

• Translating Bytecode to Machine Code: Traditionally, PHP code is interpreted on the fly. With the JIT compiler, the Zend Engine’s generated bytecode is translated into native machine code during runtime. This enables faster execution of resource-intensive tasks because native code runs more swiftly than interpreted code.
• Dynamic Compilation: JIT does not compile the entire codebase upfront. Instead, it focuses on frequently executed or computationally intensive code paths, which minimizes overhead and increases efficiency.
• Performance Optimizations: The JIT compiler can apply various optimizations such as loop unrolling, function inlining, and other performance-enhancing techniques, leading to quicker code execution.

Benefits and Use Cases

• Performance Improvement: Although PHP is primarily designed for web development where most operations are I/O-bound, JIT is especially beneficial for CPU-intensive tasks like image processing, scientific computations, or executing complex algorithms.
• Compatibility: JIT is integrated into PHP’s existing execution mechanism and doesn’t require developers to rewrite their code. It can be enabled or disabled via configuration settings.
• Expectations: While JIT promises significant performance gains in certain scenarios, for most web applications the improvement might be less noticeable. However, JIT paves the way for PHP to be used more broadly beyond traditional web development scenarios, potentially transforming it into a more versatile language suitable for a wider range of computational tasks.

Attributes

Attributes (previously referred to as annotations in other languages) in PHP 8 provide a built-in mechanism for adding metadata to classes, methods, properties, constants, and functions. Unlike PHPDoc comments, which required external libraries to parse and process, attributes are a native part of the language, processed at the syntax level, offering better performance and reliability.

Key Points about Attributes

• Syntax: Attributes are declared using the syntax #[Attribute] placed immediately before the declaration of a language element (class, method, property, etc.). For example:

  	#[Example('value')]
  class MyClass {
      #[AnotherAttribute]
      public function myMethod() { }
  }
  	

• Usage: Attributes are used to attach metadata that can later be retrieved via reflection. This allows developers to write code that reacts to the presence of certain attributes without having to parse PHPDoc comments or rely on external libraries.
• Defining Custom Attributes: You can create your own attributes by defining classes and using the built-in #[Attribute] attribute. For instance:

  	#[Attribute]
  class Example {
      public function __construct(public string $value) {}
  }
  	

Benefits for using PHP8 Attributes

• Strict Validation: Attributes are validated at compile time, reducing errors related to incorrect metadata.
• Performance: Unlike PHPDoc, attributes do not require parsing string comments, and they allow direct operations on objects, which speeds up metadata handling.
• Reflection Integration: PHP’s reflection API provides methods for retrieving attributes, which simplifies development of frameworks and tools that rely on metadata.

Named Arguments

Named Arguments are one of the significant innovations in PHP 8, allowing you to specify argument values by parameter name rather than by order when calling functions or methods. This simplifies function calls, improves code readability, and allows you to skip optional arguments.

Instead of passing arguments in positional order, you can explicitly specify which parameter is assigned which value:

function createUser(string $name, int $age, bool $isAdmin = false) {
    // ...
}

// Using named arguments:
createUser(name: "John", age: 30);

Here, the name and age parameters are explicitly provided, and the default value for isAdmin remains unchanged.

Advantage to Use named Arguments in PHP8

• Improved Readability: The code becomes more understandable since it’s clear which value is being passed to which parameter.
• Flexibility: You can pass arguments in any order and skip optional parameters without needing to specify default values explicitly.
• Error Reduction: It minimizes mistakes due to incorrect argument order, especially in functions with many parameters.

Match operator

PHP 8 introduced the match operator, which is an improved version of the traditional switch. The term “Match expression v2” may refer to subsequent improvements or extensions made to this operator. Let’s look at the basic functionality of match and its features:

Key Features of the match Expression:

• Unlike switch, the match expression returns a value. This allows it to be used directly within other expressions or assigned to variables:

  	$status = match($code) {
      200, 201 => 'OK',
      404 => 'Not Found',
      default => 'Unknown',
  	};
  	

• The match expression uses strict comparison (===) to match values, eliminating ambiguities caused by implicit type juggling.
• There is no need for break statements, as match automatically stops evaluation once a match is found.
• You can list several values that should result in the same outcome, separated by commas

Potential Extensions and Improvements (Match expression v2):

• Support for more complex conditions or logical expressions within match constructs.
• Enhanced type handling or matching mechanisms that offer finer control over matching logic.
• Extended integration with reflection or attributes for dynamic data matching.

Saner String to Number Comparisons in PHP 8

In previous versions of PHP, comparisons between strings and numbers sometimes led to unexpected results due to implicit type juggling. PHP 8 introduces changes aimed at more predictable and reasonable behavior when comparing strings with numbers. This approach is often referred to as “saner string to number comparisons.”

var_dump("123abc" == 123);  // In PHP 7: true, because "123abc" is converted to 123
var_dump("abc" == 0);       // In PHP 7: true, because "abc" is converted to 0

in PHP8

var_dump("abc" == 0);      // In PHP 8: false — the string "abc" is not implicitly converted to the number 0
var_dump("123abc" == 123); // In PHP 8: likely true, as the numeric prefix "123" is correctly converted to a number

Constructor Property Promotion

Constructor Property Promotion is one of the key features introduced in PHP 8 that significantly reduces boilerplate code when declaring and initializing class properties via the constructor. Instead of separately declaring properties and then assigning them in the constructor, you can combine these steps, making the code more concise and readable.

Previously, property declarations in a class looked like this:

class User {
    private string $name;
    private int $age;

    public function __construct(string $name, int $age) {
        $this->name = $name;
        $this->age = $age;
    }
}

Using Constructor Property Promotion in PHP 8, the code is shortened to:

class User {
    public function __construct(
        private string $name,
        private int $age
    ) {}
}

Example Usage:

class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0
    ) {}
}

$point = new Point(1.0, 2.0, 3.0);
echo $point->x; // 1.0

Union Types

PHP 8 introduced support for union types, allowing function parameters, return types, and properties to accept values of multiple types. Union types enable developers to precisely describe the allowed types of data, enhancing code reliability and leveraging benefits of static typing.

You can specify multiple allowable types using the | operator:

function processValue(int|float|string $value): int|float|string {
    // ...
}

Here, the parameter $value and the return value can be of type int, float, or string. PHP ensures that passed values match at least one of the declared types. If a value doesn’t match any of the allowed types, a TypeError is thrown.

Union types can be used not just for function parameters and return types but also for class properties:

class Example {
    public int|float $number;
}