PHP 8.4 What's changed and what's new?

-sidebar-toc> -language-notice>

With the addition of additional features, upgrades along with deprecations expect that 2024 will witness the release of PHP's cycle which will include the end of a security release compatible with every version of PHP at present and was synced to the end of the year, instead of releasing on the GA anniversary.

Additionally the support period was extended to one year. That means that you'll be making use of PHP 8.4 in a safe method until 2028 (with two years of security and fix for bugs, and two years of only security updates).

If you're looking to spend longer time with PHP 8.4 but, you'll need to find the latest features in this latest version today. We'll get right into it.

Improved features and enhancements are available in PHP 8.4

Hooks to secure your property

To illustrate the way property hooks may be utilized as a substitute for the class below, which contains the property which include in the form of dimensions and the flavor. The properties are protected by privacy view, which protects them from being accessed by anyone who is not an integral part of the object. This is because of the fact that these techniques are accessible to all users all over the world, which allows access to the properties

class Coffeeend of the class. It is possible to make the coffee you'd like to drink. Coffee('Small' "Pumpkin Spice') Print the getSize for the coffee() . ' ' . $coffee->getFlavor(); // Prints "Small Pumpkin Spice" // Change order $coffee->setSize('Grande'); $coffee->setFlavor('Mocha'); print $coffee->getSize() . ' ' . $coffee->getFlavor(); // Prints "Grande Mocha"

There may be a lot of properties, so instead of composing different methods for getting and setting the types you employ PHP's _get and set magical techniques. There's a chance you can determine the issue using messy switching declarations such as the one below.

// __set magic method example public function __set(string $key, $value): void switch ($key) case 'size': $this->size = $value; break; case 'flavor': $this->flavor = $value; break; default: throw new InvalidArgumentException('Invalid input'); } // Later, we can change the coffee order like this: $coffee->size = 'Grande'; $coffee->flavor = 'Mocha';

The method you decide to use, the larger quantity of properties you'll get in your class, and how long the code uses to change the properties will be with respect to their defined values in the upper portion of your class file. Furthermore, some methods that employ the "_get" and set magical techniques could suddenly give access to secure or private properties inside the class you've would never have thought about exposing.

Property hooks are fresh and allowed setting and getter functions along with the property's properties. In the property hooks examples below, you'll find that the property size as well as the flavor properties in the Coffee class have been made public. We've also added a few simple checks for set hooks. sets of hooks to distinguish these from assignments directly.

// Property definitions at the top of our Coffee class class Coffee public string $flavor set(string $value) if (strlen($value) > 16) throw new InvalidArgumentException('Input is too long'); $this->flavor = $value; public string $size set(string $value) if (! in_array($value, array('Small', 'Grande'))) throw new InvalidArgumentException('Not a valid size'); $this->size = $value; // Rest of the Coffee class // Define a coffee $coffee = new Coffee(); $coffee->size = 'Grande'; $coffee->flavor = 'Pumpkin spice';

Like what you are seeing in the below examples, the hook that is called a get hook is able to blend functions to create what seems to be a common reference to a property in an object.

/Simplified Coffee class classes Coffee/If you add a flavor to the coffee when $coffee is new () and $coffee->flavor = new() the $coffee->flavor variable is "Pumpkin". stores the value "Pumpkin" Print the"Pumpkin Spice" flavor in the $coffee->flavor variable. Prints "Pumpkin Spice"

Contrary to PHP magic tricks Property hooks can be used in interfaces, as well as abstract classes. An interface example:

interface Coffee: get; set;

Asymmetrical visibility

Getter and Setter which are publicly visible methods were discussed earlier are the most common way to access private or secure properties belonging to the classes they belong to.

One interesting aspect of PHP 8.4 is the possibility of properties with different levels of visibility, based on the context that it's used in. So, a property can be visible when read but private when secured with a changing the security.

Have a look at:

class coffee class: Coffee private(set) flavour is "Pumpkin Spice The $coffee is one that has a unique flavour() print the flavor of the coffee. The printout is "Pumpkin Spice" The taste of the flavor's $coffee->flavor's is "Mocha.". Error message (visibility)

In the preceding illustration, it's evident that the class's taste property can only be used when it is set. The concept is fairly straightforward and asymmetric visibility gives you an opportunity to escape:

class Public Coffee is presumed when the context is not changing private(set) the $flavor string is 'Pumpkin Spice';

Property hooks as well as asymmetric visibility that allow for a huge range of possibilities when using property hooks of an object with various visibility.

Chaining is a fresh idea with no parentheses

Shorthands are shorthands in the event of a sentence. There are the brand new chains and methods of chaining which require to place the call in brackets like this:

$coffee = (new Coffee())->getFlavor()->getSize();

PHP 8.4 allows this:

$coffee = new Coffee()->getFlavor()->getSize();

It may seem simple, but the deletion of just two parentheses makes the code easy to understand and troubleshoot.

The new functions allow you to search the variety of items

In the "You believe we shouldn't be able to have this?" Section, PHP 8.4 introduces the function array_find(), which searches the array for members that meet the criteria that are specified within the callback. The function returns the value of the first element that meets the callback's test.

The latest release adds additional functions that are related to it.

• array_find_key(): Like array_find(), but the returned value represents the key for the matching element rather than the element's value.
• array_all(): Returns true when every component of the array that is being examined matches the test that the callback is performing.
• array_any(): Returns the value in the event that at least one element in the array matches with the criteria of the callback.

It's crucial to know that the two functions will give the boolean kind of indicator, but not array keys, nor content.

Here are some examples:

$array = [ 'a' => 'Mocha', 'b' => 'Caramel', 'c' => 'Maple', 'd' => 'Pumpkin' ]; // Find the first flavor name that is 5 characters long var_dump(array_find($array, function (string $value) return strlen($value) == 5; )); // Returns "Mocha," even though "Maple" is the same length // Find the array key for the first flavor with a name longer than 5 characters. var_dump(array_find_key($array, function (string $value) return strlen($value) > 5; )); // Returns "b" // Check to see if any flavor name is less than 5 characters long var_dump(array_any($array, function (string $value) return strlen($value)

HTML5 parsing

HTM5 is the industry standard to structure modern web pages. It is the Document Object Model (DOM) technology to parse HTML had been discontinued at HTML 4.01.

Instead of creating a brand new document class, which works conjunction with the previous HTML standards, PHP 8.4 comes with an entirely fresh DomHTMLDocument class, which is HTM5 ready.

There is a way to import the content of an HTML5 website in this way:

$document = DomHTMLDocument::createFromString($html)

In addition to the createFromString($html) constructor above, the class also supports createFromFile($path) and createEmpty()

The parser has been able to recognize semantic HTML5 tags, such as the primary, article section, and section which are familiar by the vast majority of us.

Multibyte trim features

Another new feature that is part of PHP 8.4 which appears to be a long time coming is multibyte support in trim functions.

• mb_trim()
• mb_ltrim()
• mb_rtrim()

Similar to the long-running PHP trim() function, the function mb_trim removes the white space, as well as particular characters, like line feeds, at both ends of the string and may also include multibyte characters. Other functions may cut both sides of a string.

Security Precautions in PHP 8.4

Every release of PHP has a wide range of brand innovative functions and features (some quite obscure) that have been flagged as potential removals of this PHP platform. One of the biggest changes to be found in PHP 8.4 is that it does not use cookies for session tracking.

Deprecation of the session GET/POST

The new version of PHP PHP 8.4 the usage of either these settings will trigger a warning about deprecation that could show up in the website's logs. Once PHP 9 is released, the settings won't be in use.

Other adjustments (and removals) within PHP 8.4

This is a comprehensive listing of features to be removed by the PHP developers who who are responsible for PHP 8.4. (Some have links to additional details on the capabilities.,

• In a formal manner, deprecate soft-deprecated characteristics of the DOMDocument as well as properties of the DOMEntity. properties.
• Removed DOMImplementation::getFeature($feature, $version).
• Deprecate DOM_PHP_ERR constant.
• Remove the "S" tag inside our informalized().
• Deprecate session.sid_length and session.sid_bits_per_character.
• Deprecate SplFixedArray::__wakeup().
• Eliminate the set_object the xml() and the set_*_handler() with string method names.
• It's not recommended to utilize either null or false values in the function key_split of dba_key().
• Be sure to avoid sending incorrect data forms using the function ext/hash for various options.
• Deprecate constants SUNFUNCS_RET_STRING, SUNFUNCS_RET_DOUBLE, SUNFUNCS_RET_TIMESTAMP.
• Avoid using the proprietary CSV escape technique.
• Deprecate E_STRICT constant.
• Deprecate strtok().
• Refrain from returning value that is not a string to the output handler, for the benefit of.
• It's not advised to produce output within a user-specific output handler.
• Eliminate file_put_contents() with the value $data as an array.
• Take out mysqli_ping() and mysqli::ping()
• Deprecate mysqli_refresh().
• Deprecate mysqli_kill().
• Deprecate the second parameter to mysqli_store_result().
• Deprecate lcg_value().
• Deprecate the term uniqid().
• Remove the md5() or sha1() as well as sha1_file() as well as sha1_file().
• It's not advised to use E_USER_ERROR to cause the error().
• Do not use a single underscore ("_") to indicate the name of the class.
• Deprecate SOAP_FUNCTIONS_ALL constant and passing it to SoapServer::addFunction().

Summary

     What of these PHP 8.4 features do you prefer? Let us know your thoughts regarding the features from the PHP 8.4 group in the comments!

Steve Bonisteel

Steve Bonisteel is a Technical Editor on the website. His writing journey began in the newspaper industry, as a reporter who chased ambulances and fire trucks. The writer has been writing about internet-related technology since the mid-90s.

Article was posted on this site

This post was posted on here