PHP 8.5 Released

[Weedpacket]

https://www.php.net/releases/8.5/en.php

There are half a dozen significant new features in this release.

URI Extension
For working with URIs and URLs in standards-compliant ways (two different standards because sigh politics).

Clone With
When cloning an object, you might want to make changes along the way to the clone. Instead of cloning the object and then going through and making the changes, you can do both in one step.

\NoDiscard Attribute
For some functions, throwing away the return value can be a sign you're Doing It Wrong™. With this attribute in place, you'll be told you're doing that. If you really did want to discard it, a (void) cast overrides the message.

Closures in constant expressions
As well as scalar types and arrays, you can now use closures and first-class callables where "constant expressions" are required.

Pipe Operator
Instead of chaining function calls together and then having to read them from the inside out to find out what is happening, you can build a pipeline and have the return value of each passed as an argument to the next.

Persistent cURL Shared Handles
You could already share connection settings (including things like cookies) across multiple cURL handles within a PHP session; now you can maintain them across PHP sessions as well. Which is nice if your workflow wants to maintain such state across several pages.

The migration guide is in the expected place: https://php.net/manual/en/migration85.php

[Weedpacket]

Pipe Operator

This is actually part of an ongoing sequence of syntax improvements that started back with $a = foo(...); for creating closures. There is more to come in this area.

Back in the day, I inflicted something like

	$file = array_map(fn($line) => explode(' ', $line), array_values(
		array_filter(
			array_map(trim(...),
				preg_split('/\b0\b/',
					join(' ',
						array_map(collapse_space(...),
							array_map(trim(...),
								preg_grep('/^\s*-?\d+(\s+-?\d+)*\s*$/',
									preg_grep('/^[a-z]/',
										file($filename),
										PREG_GREP_INVERT))))),
					flags: PREG_SPLIT_NO_EMPTY)),
			strlen(...))));

on you all. Notice how far some of the arguments end up from the function call they're actually part of.

The somewhat more sane way of doing it involves repeatedly reusing the variable:

$file = file($filename);
$file = preg_grep('/^[a-z]/', $file, PREG_GREP_INVERT);
$file = preg_grep('/^\s*-?\d+(\s+-?\d+)*\s*$/', $file);
$file = array_map(trim(...), $file);
$file = array_map(collapse_space(...), $file);
$file = join(' ', $file);
$file = preg_split('/\b0\b/', $file, flags: PREG_SPLIT_NO_EMPTY);
$file = array_map(trim(...), $file);
$file = array_filter($file, strlen(...));
$file = array_values($file);
$file = array_map(fn($line) => explode(' ', $line), $file);

With the pipe operator that becomes

$file = file($filename)
	|> (fn($ls) => preg_grep('/^[a-z]/', $ls, PREG_GREP_INVERT))
	|> (fn($ls) => preg_grep('/^\s*-?\d+(\s+-?\d+)*\s*$/', $ls))
	|> (fn($ls) => array_map(trim(...), $ls))
	|> (fn($ls) => array_map(collapse_space(...), $ls))
	|> (fn($ls) => join(' ', $ls))
	|> (fn($ls) => preg_split('/\b0\b/', $ls, flags: PREG_SPLIT_NO_EMPTY))
	|> (fn($ls) => array_map(trim(...), $ls))
	|> (fn($ls) => array_filter($ls, strlen(...)))
	|> array_values(...)
	|> (fn($ls) => array_map(fn($line) => explode(' ', $line), $ls));

Still a bit verbose, but like I say the syntax changes are a work in progress. Also note that the whole pipeline is, like the original nested functions but unlike the repeated assignment statements, a single expression; I could have started the pipeline with $file = !file_exists($filename) ? '' : file($filename) |> ....

[JohanFahey]

Thanks for the link

[Weedpacket]

Clone With

"Yeah, I want a new object $bar that is exactly like $foo only its generation is one greater, and an up-to-the-moment creation time."

$bar = clone($foo, ['generation' => $foo->generation + 1, 'creation' => hrtime(true)]);

[Weedpacket]

Array First/Last Value Functions

PHP 7.3 added the array_key_first and array_key_last functions that would return respectively the first and last keys (in iteration order) of an array. PHP 8.5 introduces array_first and array_last to do the same thing but for values.

The reason for the earlier functions being adopted earlier was because:

(a) It's easy to get the first value for a given key ($value = $a[$key]); getting the first key for a given value involves searching ($key = array_first(array_keys($a, $value)))

(b) Both of those ignore the case where the $a is empty. If it is, array_key_first can make the distinction by returning null instead of the integer or string that a key must be; array_first might return null because the array's empty or because that's the first value in the array. It's basically a matter of whether you want to check before or after:

$key = array_key_first($array);
if($key === null) {
    // deal with empty array
} else {
    // do stuff
}

vs.

if(empty($array)) {
    // deal with empty array
} else {
    $value = array_first($array);
    // do stuff
}

, keeping point (a) above in mind.