PHP 8.2: What’s New and How to Get Started

Introduction

PHP 8.2 continues to build upon the performance enhancements and novel capabilities introduced in PHP 8.0 and 8.1. This release primarily emphasizes the incorporation of modest yet valuable refinements to the language and its standard library. Among the prominent highlights are:

1. Enumerations: A novel data type is introduced, facilitating the definition of collections of named constants.
2. Readonly Properties: This entails the creation of class properties that remain immutable after their construction.
3. First Class Callable Syntax: An innovative and unified syntax is implemented for the definition of callbacks and closures.
4. Disjunctive normal form (DNF) types: DNF types enable the specification of multiple potential types for a variable. This proves advantageous in representing data that can assume various forms, including instances like a string or an integer.
5. Constants in Traits: Now it is feasible to define constants within traits.
6. New Functions: Notable and pragmatic additions to the standard library encompass functions like str_contains() and str_starts_with().
7. Deprecations: Elimination of outdated legacy functionalities that have become obsolete.

In essence, PHP 8.2 introduces gradual enhancements while upholding compatibility with preceding PHP 8.x versions. Now, let’s delve into a more comprehensive exploration of some of the significant new features.

PHP 8.2 New Features

Enumerations

One of the highly anticipated enhancements coming to PHP 8.2 is the introduction of enumerations. This novel data type enables the creation of named constants that represent a predetermined set of feasible values.

To illustrate:

enum UserStatus {
  case Active,
  case Inactive,
  case Archived,
}

This code snippet establishes a fresh enumerated category labeled UserStatus, encompassing potential states such as Active, Inactive, and Archived.

Several notable benefits associated with enumerations are as follows:

1. Enhanced code clarity and self-explanatory nature.
2. Type safety is heightened, limiting values to those specifically defined as constants.
3. Inclusion of inherent methods like UserStatus::cases().

Collectively, enumerations furnish a more streamlined approach for managing sets of constants within the PHP framework.

Readonly Properties

PHP 8.2 ushers in the concept of readonly properties. With this feature, object properties can be designated as readonly, thus restricting their modification solely to the object’s construction phase.

class User {

  public readonly int $id;
  
  public function __construct(int $id) {
    $this->id = $id; 
  }

}

Attempting to modify a readonly property outside the constructor will throw an error. This is useful for defining immutable properties on objects.

First Class Callable Syntax

PHP 8.2 provides a new unified syntax for defining callbacks, closures and callable objects using the callable keyword:

// Callable class
class Logger {
  public function log(string $msg) {
    echo $msg;
  }
}

// Callable closure
$logger = callable(fn(string $msg) => print($msg)); 

// Callable array
$logger = callable([new Logger, 'log']);

This makes working with callables clearer and more consistent across different types.

Disjunctive normal form (DNF) types:

class Foo {
    public function bar(mixed $entity) {
        if ((($entity instanceof A) && ($entity instanceof B)) || ($entity === null)) {
            return $entity;
        }

        throw new Exception('Invalid entity');
    }
}

class Foo {
    public function bar((A&B)|null $entity) {
        return $entity;
    }
}

Constants in Traits

Traits serve the purpose of enabling lateral code sharing among classes. Presently, they permit the declaration of methods and properties, though not constants. Consequently, the capacity to establish invariants anticipated by a trait within the trait itself is absent. As a result, certain situations demand alternative approaches, such as introducing constants within the encompassing class of the trait or within an interface implemented by the said class.

trait Foo
{
    public const CONSTANT = 1;
}

class Bar
{
    use Foo;
}

var_dump(Bar::CONSTANT); // 1
var_dump(Foo::CONSTANT); // Error

Direct access to a constant via the trait’s name is unavailable; however, you can access the constant through the class that incorporates the trait.

New Functions

PHP 8.2 adds several new useful functions to the standard library:

• str_contains() – check if a string contains a substring
• str_starts_with() and str_ends_with() – check strings against prefixes/suffixes
• get_debug_type() – returns runtime type of an object

And more. These provide convenient shortcuts for common string and type checking operations.

Deprecations

Some old legacy functionality has been deprecated in PHP 8.2, including:

• create_function() – deprecated due to security concerns
• FILTER_FLAG_SCHEME_REQUIRED and FILTER_FLAG_HOST_REQUIRED filter flags – unreliable validation

See the full list of deprecations for details. These will be removed in future PHP versions.

Conclusion

In conclusion, PHP 8.2 introduces gradual enhancements while upholding compatibility with preceding 8.x versions. The additions of features such as enums, readonly properties, first-class callables, and deprecations serve to bolster PHP’s standing as a resilient and refined language apt for the creation of extensive web applications.

This minor version release mitigates the potential risks associated with upgrading, facilitating seamless testing and integration of the fresh functionalities. For novel endeavors, commencing with PHP 8.2 is advisable to leverage the most recent enhancements and optimal methodologies.