PHP 8.2 new features

PHP 8.2 is the latest release of the popular server-side scripting language. It introduces several new features and improvements that make PHP more powerful, efficient, and developer-friendly. In this article, we will explore some of the key changes and enhancements in PHP 8.2 and provide examples of how to use them.

Constructor Property Promotion in Classes

One of the most anticipated features in PHP 8.2 is constructor property promotion, which allows you to declare and initialize class properties directly in the constructor parameters. This makes it easier to write and read code, especially for classes with many properties.

Here’s an example of how to use constructor property promotion:

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

In this example, the User class has four properties ($name, $age, $email, and $password), all of which are declared and initialized in the constructor parameters. This eliminates the need for separate property declarations and assignments, making the code more concise and readable.

The str_starts_with() and str_ends_with() Functions

PHP 8.2 introduces two new string functions, str_starts_with() and str_ends_with(), which allow you to check if a string starts or ends with a given substring, respectively. These functions are useful for performing simple string manipulations and validations.

Here’s an example of how to use str_starts_with() and str_ends_with():

$email = 'john@example.com';
if (str_starts_with($email, 'john')) {
  echo 'The email starts with "john"';
}

$filename = 'script.js';
if (str_ends_with($filename, '.js')) {
  echo 'The file is a JavaScript file';
}

In this example, we use str_starts_with() to check if the $email string starts with the substring “john”, and str_ends_with() to check if the $filename string ends with the substring “.js”. If the conditions are met, we print a message to the screen.

The str_contains() Function

Another new string function in PHP 8.2 is str_contains(), which allows you to check if a string contains a given substring. This function is similar to strpos(), but returns a boolean value instead of the position of the substring.

Here’s an example of how to use str_contains():

$fruit = 'apple';
if (str_contains($fruit, 'p')) {
  echo 'The fruit contains the letter "p"';
}

In this example, we use str_contains() to check if the $fruit string contains the letter “p”. If it does, we print a message to the screen.

The fdiv() Function

PHP 8.2 introduces a new mathematical function, fdiv(), which performs floating-point division and returns a float value. This function is similar to the / operator, but provides more accurate results for certain types of calculations.

Here’s an example of how to use fdiv():

$num1 = 0.1;
$num2 = 0.2;
$result = fdiv($num1, $num2);
echo $result; // Output: 0.5

In this example, we use fdiv() to perform floating-point division between $num1 and $num2, and store the result in $result. We then print the value of $result to the screen.

The get_debug_type() Function

PHP 8.2 also introduces a new function, get_debug_type(), which allows you to get the type of a variable in a human-readable format. This function is useful for debugging and error handling, as it provides more detailed information about the type of a variable than the built-in gettype() function.

Here’s an example of how to use get_debug_type():

$value1 = 'hello';
$value2 = 42;
$value3 = true;

echo get_debug_type($value1); // Output: string
echo get_debug_type($value2); // Output: integer
echo get_debug_type($value3); // Output: boolean

In this example, we use get_debug_type() to get the type of three different variables ($value1, $value2, and $value3) and print the results to the screen. As you can see, get_debug_type() returns a human-readable string that describes the type of the variable.

The @ Operator for Ignoring Errors

PHP 8.2 introduces a new use case for the @ operator, which is used to suppress error messages. Previously, using @ to suppress errors was generally considered bad practice, as it could lead to hard-to-debug issues. However, in PHP 8.2, the @ operator can be used in conjunction with the match expression to suppress errors when handling optional values.

Here’s an example of how to use the @ operator with the match expression:

$optionalValue = null;
$result = match (@$optionalValue) {
  1 => 'One',
  2 => 'Two',
  default => 'Unknown'
};
echo $result; // Output: Unknown

In this example, we use the @ operator to suppress any errors that may occur when $optionalValue is null. We then use the match expression to handle three possible values of $optionalValue (1, 2, and null) and return a corresponding string. If $optionalValue is null, the match expression will evaluate to the default branch and return “Unknown”.

The str_contains() Function Supports Arrays

In addition to the new str_contains() function for strings, PHP 8.2 also extends this function to support arrays. When used with an array, str_contains() will return a boolean value indicating whether any element of the array contains a given substring.

Here’s an example of how to use str_contains() with an array:

$fruits = ['apple', 'banana', 'pear'];
if (str_contains($fruits, 'an')) {
  echo 'At least one fruit contains the letters "an"';
}

In this example, we use str_contains() to check if any element of the $fruits array contains the sub string “an”. If at least one element does, we print a message to the screen.

Conclusion

PHP 8.2 introduces several new features and improvements that make the language more powerful and developer-friendly. The new constructor property promotion feature makes it easier to write and read code for classes with many properties, while the str_starts_with(), str_ends_with(), and str_contains() functions provide simple yet powerful string manipulation capabilities. The new fdiv() and get_debug_type() functions offer improved mathematical and debugging capabilities, respectively, while the new use case for the @ operator in conjunction with the match expression provides a more streamlined approach to handling optional values. Finally, the extension of the str_contains() function to support arrays adds even more flexibility and versatility to PHP’s string manipulation capabilities.

Thanks for reading.