Partial Function Application

RFCs: partial_function_application_v2, partial_function_application_optional_placeholder

Ein ? an Stelle eines Arguments macht aus dem Aufruf eine Closure für den Rest. Benannte Platzhalter ordnen Parameter um, ... sammelt alles noch nicht Übergebene ein, und die erzeugte Closure behält Typen, Defaults und Referenz-Flags für Reflection.

Das ist die fehlende Hälfte der First-Class-Callables aus 8.1 und der natürliche Partner des Pipe-Operators aus 8.5. array_map(str_replace('a', 'b', ?), $list) ersetzt eine Zeile Arrow-Function-Boilerplate, und statische Analyse sieht die echte Signatur. Ein Folge-RFC hat jeden ?-Platzhalter zum Pflichtparameter gemacht: die Stelligkeit, die du schreibst, ist die, die du bekommst.

// Fix some arguments now, supply the rest later
$greet = str_replace('hello', 'hi', ?);
echo $greet('hello world');              // hi world

// Placeholders compose with the 8.5 pipe operator
$slugs = ['Hello World', 'PHP 8.6']
    |> array_map(strtolower(...), ?)
    |> array_map(str_replace(' ', '-', ?), ?);
print_r($slugs);                         // hello-world, php-8.6

// "..." keeps the remaining parameters, defaults included
$encode = json_encode(?, JSON_THROW_ON_ERROR, ...);
echo $encode(['ok' => true]);            // {"ok":true}

Default-Werte für readonly-Properties

RFC: readonly_property_defaults 24–0 angenommen

Readonly-Properties dürfen jetzt einen Default deklarieren; der Default gilt als die einzige Initialisierung. Zusammen mit Interface-Properties aus 8.4 ergibt das vertragliche Konstanten pro Klasse ohne Konstruktor-Zuweisungen.

Der ursprüngliche readonly-RFC nannte Defaults „nicht besonders nützlich“. Interface-Properties haben das geändert: Ein readonly-Default erfüllt einen { get; }-Vertrag ohne Boilerplate. Vorsicht: Eine Zuweisung im Konstruktor ist jetzt eine Änderung und wirft, und unset() auf so einer Property ist ein Fehler.

interface Ingestor
{
    public string $name { get; }
    public array $steps { get; }
}

// Fixed metadata without constructor boilerplate:
// the default IS the initialising assignment
final readonly class ChangelogIngestor implements Ingestor
{
    public string $name = 'changelog';
    public array $steps = [ParseMarkdown::class, ExtractVersions::class];
}

echo new ChangelogIngestor()->name;      // changelog

Property-Schreibzugriffe auf Objekte in Konstanten

RFC: const_object_property_write 17–2 angenommen

Objekte in Konstanten gibt es seit 8.1, aber jeder Schreibzugriff wie CONST->prop = 1 starb mit „Cannot use temporary expression in write context“. PHP 8.6 hebt das für Property-Zuweisungen, Compound-Operatoren, Inkremente, isset(), unset() und Referenz-Übergabe auf.

Die Bindung der Konstante bleibt unveränderlich, nur der Objektzustand ändert sich, genau wie Objekte sich überall sonst verhalten. Array-Konstanten bleiben unverändert (Copy-on-Write). Nebenwirkung: Ein Schreibzugriff auf die Property eines Enum-Case wirft jetzt den normalen readonly-Fehler statt eines Compile-Fatals.

const REGISTRY = new stdClass();

// PHP 8.5: Fatal error: Cannot use temporary expression in write context
// PHP 8.6: the constant still binds the same object, its state may change
REGISTRY->hits = 0;
REGISTRY->hits++;
REGISTRY->hits += 10;

class Config
{
    const SETTINGS = REGISTRY;
}

Config::SETTINGS->debug = true;
var_dump(REGISTRY->hits, isset(Config::SETTINGS->debug)); // int(11) bool(true)

Time\Duration

RFC: duration_class 35–1 angenommen 30 multiplyBy, divideBy, neg… · 2 mul, divBy, neg, abs entschieden

Eine finale, readonly Stoppuhr-Dauer mit Nanosekunden-Präzision: Fabriken von Sekunden bis Nanosekunden und aus ISO-8601-Strings, add/sub/multiplyBy/divideBy, Vergleichsoperatoren und ein überlaufsicherer Bereich von rund 292 Jahren.

Timeouts, Backoff und Scheduling waren bisher int-in-irgendeiner-Einheit oder fragile Floats. DateInterval schleppt Kalendereinheiten mit, die sich nicht zuverlässig in Sekunden umrechnen lassen. Duration ist per Konstruktion einheitensicher und bereits der Timeout-Typ der neuen Polling-API; weitere interne APIs werden folgen. sleep() und Verwandte nehmen weiterhin int.

use Time\Duration;

// Stop-watch time with nanosecond precision, no calendar semantics
$timeout = Duration::fromMilliseconds(1_500);
$backoff = $timeout->multiplyBy(2)->add(Duration::fromSeconds(1));

var_dump($backoff->seconds, $backoff->nanoseconds); // int(4) int(0)
var_dump($timeout < $backoff);                       // bool(true)

// ISO 8601 without date parts: hours are the largest unit
$limit = Duration::fromIso8601DurationString('PT1H30M');
var_dump(Duration::compare($backoff, $limit));       // int(-1)

#[\Override] auf Klassenkonstanten

RFC: override_constants

Das Attribut, das 8.3 für Methoden einführte und 8.5 auf Properties erweiterte, gilt jetzt auch für Klassenkonstanten und Enum-Cases. Der Compiler meldet einen Fehler, wenn nichts überschrieben wird.

Eine Elternkonstante versehentlich zu überschreiben ist ein klassischer stiller Bug. Die markierte Absicht macht Refactorings sicher: Wird die Elternkonstante umbenannt, kompiliert das Kind nicht mehr, statt leise eine neue Konstante zu definieren.

class Base
{
    protected const RETRIES = 3;
}

class Worker extends Base
{
    #[\Override]                 // compile error if Base had no RETRIES
    public const RETRIES = 5;
}

enum Level: int implements HasDefault
{
    #[\Override]                 // enum cases may override interface constants
    case Default = 0;
}

__debugInfo() auf Enums

RFC: debugable-enums

Enums dürfen jetzt __debugInfo() implementieren; var_dump() behält den enum(Foo::Bar)-Kopf und hängt an, was die Methode zurückgibt.

Enum-Ausgaben in Dumps und Debuggern waren fix und knapp. Backed Enums mit sprechenden Werten oder Cases, die auf Konfiguration zeigen, können sich jetzt selbst erklären. __toString() auf Enums wurde diskutiert und zugunsten dieser engeren Änderung verworfen.

enum Status: string
{
    case Active = 'active';

    public function __debugInfo(): array
    {
        return [self::class . '::' . $this->name . ' = ' . $this->value];
    }
}

var_dump(Status::Active);
// enum(Status::Active) (1) {
//   [0]=>
//   string(23) "Status::Active = active"
// }

Doc-Comments an Parametern

RFC: parameter-doccomments

Ein /** … */-Kommentar vor oder hinter einem Parameter wird von der Engine aufbewahrt und über das neue ReflectionParameter::getDocComment() zurückgegeben.

Parameter-Dokumentation muss Name und Typ nicht mehr in einer @param-Zeile über der Funktion wiederholen, wo sie unbemerkt auseinanderläuft. Attribut-getriebene Frameworks und API-Generatoren holen den Text direkt aus der Reflection.

/** Search for entries matching a query */
function search(
    /** Terms to look for in the index */
    string $query,
    /** Maximum number of entries returned */
    int $limit = 10,
): array {
    return [];
}

foreach (new ReflectionFunction('search')->getParameters() as $p) {
    echo $p->name, ': ', $p->getDocComment(), PHP_EOL;
}
// query: /** Terms to look for in the index */
// limit: /** Maximum number of entries returned */

Zustandslose Closures werden gecacht

RFC: closure-optimizations

Eine statische Closure, die keine Variablen einfängt und keine static-Variablen deklariert, wird einmal erzeugt und wiederverwendet. Zwei solche Closures aus derselben Quellzeile sind jetzt identische Objekte.

Hot Paths, die pro Iteration dieselbe Closure bauen, allozieren nicht mehr. Der zweite Teil des RFC, static für Closures ohne $this-Nutzung automatisch abzuleiten, wurde nach der Abstimmung wegen eines Randfalls mit Callable-Strings zurückgezogen; markiere Closures selbst als static, um den vollen Effekt zu bekommen.

function handler(): Closure
{
    // static, captures nothing, no static variables => cached
    return static fn (int $x): int => $x * 2;
}

// PHP 8.5: two instances. PHP 8.6: the same cached Closure.
var_dump(handler() === handler());       // bool(true)

clamp()

RFC: clamp_v2

clamp($value, $min, $max) liefert den Wert, wenn er innerhalb der Grenzen liegt, sonst die nächste Grenze. Es akzeptiert alles Vergleichbare, auch Strings und DateTime-Objekte, und wirft einen ValueError, wenn $min größer als $max oder eine Grenze NAN ist.

Das übliche max($min, min($max, $v)) versteckt zwei Bugs: vertauschte Grenzen und NAN, das leise durchrutscht. Die native Version prüft beides und ist etwas schneller als der Userland-Ternary.

var_dump(clamp(150, min: 0, max: 100));  // int(100)
var_dump(clamp(42, 0, 100));             // int(42)
var_dump(clamp(2.5, 1, 3));              // float(2.5)

// Any comparable type follows the usual comparison rules
echo clamp(
    new DateTimeImmutable('2026-12-24'),
    new DateTimeImmutable('2026-11-19'),
    new DateTimeImmutable('2026-12-01'),
)->format('Y-m-d');                      // 2026-12-01

clamp(4, 8, 6);   // ValueError: $min must be smaller than or equal to $max

Strukturierte Stream-Fehler

RFC: stream_errors

Ein Stream-Context kann die Fehlerbehandlung auf Exceptions oder stilles Sammeln umstellen: error_mode (Error, Exception, Silent), error_store und ein error_handler-Callback. Fehler kommen als StreamError-Wertobjekte mit StreamErrorCode-Enum, Wrapper-Name, Schweregrad und betroffenem Pfad.

Bis jetzt meldeten file_get_contents() und Co. Fehler über Warnings, die man mit einem Error-Handler abfangen und als Text parsen musste. Mit StreamErrorMode::Exception ist ein fehlgeschlagenes Öffnen eine StreamException mit maschinenlesbaren Codes; die Defaults bleiben unangetastet, es ändert sich nur, was du anforderst.

$ctx = stream_context_create([
    'stream' => ['error_mode' => StreamErrorMode::Exception],
]);

try {
    $config = file_get_contents('/etc/app/missing.ini', false, $ctx);
} catch (StreamException $e) {
    foreach ($e->getErrors() as $error) {
        echo $error->code->name, ': ', $error->message, PHP_EOL;
        // OpenFailed: Failed to open stream: No such file or directory
    }
}

// Or stay silent and inspect afterwards
$ctx = stream_context_create(['stream' => ['error_mode' => StreamErrorMode::Silent]]);
@file_get_contents('/nope', false, $ctx);
var_dump(stream_last_errors()[0]->code === StreamErrorCode::OpenFailed); // bool(true)

Polling-API (Io\Poll)

RFC: poll_api

Eine native Multiplexing-API über epoll, kqueue, Event Ports, WSAPoll oder poll(): Io\Poll\Context überwacht Handles auf Read-, Write-, Error- und HangUp-Events, kennt One-Shot- und Edge-Triggered-Modus und gibt aus wait() die ausgelösten Watcher zurück.

stream_select() ist O(n), auf vielen Systemen bei 1024 Deskriptoren gedeckelt und weiß nichts von modernen Kerneln. Event-Loops wie Revolt, ReactPHP oder AMPHP können jetzt auf einem eingebauten Backend laufen statt auf ext-uv oder ext-event, und Runtimes im FrankenPHP-Stil bekommen eine gemeinsame interne API. In dieser ersten Version sind nur Stream-Ressourcen pollbar.

use Io\Poll\{Context, Event};
use Time\Duration;

$poll = new Context();                              // epoll / kqueue / WSAPoll
$server = stream_socket_server('tcp://127.0.0.1:8080');
stream_set_blocking($server, false);
$poll->add(new StreamPollHandle($server), [Event::Read], 'server');

while ($watchers = $poll->wait(Duration::fromSeconds(1))) {
    foreach ($watchers as $w) {
        if ($w->getData() === 'server') {
            $client = stream_socket_accept($w->getHandle()->getStream(), 0);
            $poll->add(new StreamPollHandle($client), [Event::Read], 'client');
        } elseif ($w->hasTriggered(Event::Read)) {
            $stream = $w->getHandle()->getStream();
            fwrite($stream, 'echo: ' . fread($stream, 8192));
        }
    }
}

ext/uri: Builder und Typerkennung

RFC: uri_followup

Uri\Rfc3986\UriBuilder und Uri\WhatWg\UrlBuilder bauen eine URI in einem Objekt und validieren bei build(); getUriType() unterscheidet absolute URIs von Pfad- und Netzwerk-Referenzen, getHostType() meldet IPv4, IPv6, Domain oder opaken Host, und isSpecialScheme() sagt, ob die WHATWG-Sonderregeln greifen.

Die URI-Klassen aus 8.5 kannten nur unveränderliche Wither, also ein Objekt pro Schritt und Abhängigkeit von der Aufrufreihenfolge. Der Builder beseitigt beides. Der Percent-Encoding-Helfer aus demselben RFC ist in der Beta noch nicht gelandet.

// One object instead of a wither chain that allocates per step
$uri = new Uri\Rfc3986\UriBuilder()
    ->setScheme('https')
    ->setHost('php-net.pro')
    ->setPath('/en/php-8.6')
    ->setQuery('utm_source=dispatch')
    ->build();

echo $uri->toRawString();                // https://php-net.pro/en/php-8.6?utm_source=dispatch
echo $uri->getUriType()->name;           // Uri (vs. RelativePathReference ...)

$url = Uri\WhatWg\Url::parse('https://[2001:db8::1]/');
echo $url->getHostType()->name;          // IPv6
var_dump($url->isSpecialScheme());       // bool(true) for http(s), ws(s), ftp, file

enum SortDirection

RFC: sort_direction_enum

Ein globales, nicht-backed Enum mit den Cases Ascending und Descending, gedacht als der eine Sortierrichtungs-Typ, auf den PHP, Frameworks und Bibliotheken sich einigen.

Doctrine, Query-Builder und jedes ORM bringen ein eigenes Order-Enum mit. Ein gemeinsamer Typ macht Signaturen interoperabel; eine Union mit den alten String- oder Int-Flags hält bestehende APIs kompatibel, während sie migrieren.

// One shared type instead of SORT_ASC, 'DESC', bool $ascending ...
function orderBy(string $column, SortDirection $direction = SortDirection::Ascending): string
{
    return sprintf('ORDER BY %s %s', $column, match ($direction) {
        SortDirection::Ascending => 'ASC',
        SortDirection::Descending => 'DESC',
    });
}

echo orderBy('created_at', SortDirection::Descending);   // ORDER BY created_at DESC

ReflectionProperty::isReadable() und isWritable()

RFC: isreadable-iswriteable

Beide Methoden beantworten, ob ein Lese- oder Schreibzugriff aus einem bestimmten Scope gelingen würde, wahlweise für ein konkretes Objekt. Sie verstehen readonly, asymmetrische Sichtbarkeit, Hooks und magische Accessoren, was isPublic() nie konnte.

Seit readonly (8.1) und private(set) (8.4) heißt public nicht mehr beschreibbar. Serializer, Hydratoren und Mapper mussten die Regeln der Engine nachbauen; jetzt fragen sie die Engine.

final class Money
{
    public function __construct(
        public readonly int $amount,
        public private(set) string $currency = 'EUR',
    ) {}
}

$amount = new ReflectionProperty(Money::class, 'amount');
$currency = new ReflectionProperty(Money::class, 'currency');

// isPublic() says "true" for both; the new methods answer the real question
var_dump($amount->isWritable(null));                 // bool(false) from global scope
var_dump($currency->isWritable(Money::class));       // bool(true) from inside
var_dump($currency->isReadable(null));               // bool(true)

Endianness-Modifier für pack()/unpack()

RFCs: pack-unpack-endianness-signed-integers-support, pack-unpack-float-endianness-modifier

Die Perl-Modifier < und > funktionieren jetzt auf den Integer-Codes s, l, q, S, L, Q und den Float-Codes f und d. Auf Codes mit fester Byte-Reihenfolge werfen sie einen ValueError.

Ein vorzeichenbehafteter Little-Endian-int32 brauchte bisher drei unpack()-Aufrufe und Bit-Shifts. Parser für Binärprotokolle und Dateiformate werden zu einem Format-String. Achtung bei Namen: unpack('s<value') liefert jetzt den Schlüssel value, nicht <value.

// Signed little-endian int32 used to need a manual bit dance
$bytes = pack('l<', -16909060);
print_r(unpack('l<value', $bytes));      // [value] => -16909060

// Modifiers work on s/S, l/L, q/Q and (new) f/d
$frame = pack('s>l<d>', -258, 1024, 3.14159);
[$id, $len, $ratio] = array_values(unpack('s>id/l<len/d>ratio', $frame));

pack('a<', 'x');   // ValueError: modifier not allowed on "a"

mysqli::quote_string()

RFC: mysqli_quote_string

Escapt und setzt einen String in einem Schritt in einfache Anführungszeichen, das mysqli-Gegenstück zu PDO::quote(). Verfügbar als mysqli::quote_string() und mysqli_quote_string().

real_escape_string() funktionierte nur innerhalb einfacher Anführungszeichen korrekt; mit doppelten und NO_BACKSLASH_ESCAPES war es ein Injection-Loch. Die neue Funktion entfernt das manuelle Quoting dort, wo Prepared Statements keine Option sind, etwa in Query-Buildern, die komplettes SQL rendern müssen.

// Before: quotes by hand, injection possible under NO_BACKSLASH_ESCAPES
$sql = sprintf("SELECT id FROM users WHERE name = '%s'", $mysqli->real_escape_string($name));

// PHP 8.6: escaped AND quoted, always single quotes (like PDO::quote())
$sql = sprintf('SELECT id FROM users WHERE name = %s', $mysqli->quote_string($name));
// SELECT id FROM users WHERE name = 'Don\'t!'

TLS-Session-Resumption, PSK und 0-RTT

RFC: tls_session_resumption_api

Stream-Contexts bekommen session_data, session_new_cb, session_cache und verwandte Optionen mit einem exportier- und importierbaren Openssl\Session-Objekt; psk_client_cb/psk_server_cb erlauben externe Pre-Shared Keys, und early_data bringt TLS-1.3-0-RTT.

Jeder PHP-Request begann bisher mit einem frischen TLS-Handshake. Die Session in Redis oder APCu abzulegen spart pro ausgehendem HTTPS-Aufruf einen Roundtrip, und in PHP geschriebene Server können ihren Session-Cache mit jedem Store hinterlegen.

// Skip the full handshake on the next request by persisting the session
$stored = $cache->get('tls:api.example.com');

$ctx = stream_context_create(['ssl' => [
    'peer_name'      => 'api.example.com',
    'session_data'   => $stored ? Openssl\Session::import($stored) : null,
    'session_new_cb' => function ($stream, Openssl\Session $session) use ($cache): void {
        $cache->set('tls:api.example.com', $session->export(), $session->getTimeout());
    },
]]);

$fp = stream_socket_client('tls://api.example.com:443', context: $ctx);

Intl: grapheme_strrev() und mehr

RFCs: grapheme_strrev, getdisplaykeyword_and_getdisplaykeywordvalue

grapheme_strrev() kehrt nach Grapheme-Clustern um, Emoji-Sequenzen und kombinierende Zeichen bleiben intakt. Locale::getDisplayKeyword() und getDisplayKeywordValue() lokalisieren Locale-Keywords, IntlNumberRangeFormatter formatiert Zahlenbereiche, SpoofChecker lernt bidirektionale Verwechslungen und IntlDatePatternGenerator liefert Skeletons.

Die intl-Erweiterung schließt weiter Lücken zu ICU. Das meiste ist klein, aber das Display-Keyword-Paar vervollständigt eine Familie, die seit PHP 5.3 unvollständig war.

// Reverses grapheme clusters, so family emoji and combining marks survive
echo grapheme_strrev("PHP 👨‍👩‍👧 8.6");        // 6.8 👨‍👩‍👧 PHP

// Localised labels for locale keywords
echo Locale::getDisplayKeyword('calendar', 'de');                 // Kalender
echo Locale::getDisplayKeywordValue('ja@calendar=japanese', 'calendar', 'en'); // Japanese Calendar

// Number ranges with ICU collapsing rules ("1–5 km")
$f = new IntlNumberRangeFormatter('measure-unit/length-kilometer', 'en');
echo $f->format(1, 5);

Kleinere Ergänzungen, die man kennen sollte

Das Changelog ist lang; das sind die Einträge, die am ehesten in Anwendungscode auftauchen.

• json_last_error_msg() und JsonException nennen jetzt den Offset des fehlerhaften Tokens.
• curl_getinfo() meldet size_delivered, und CURLOPT_SEEKFUNCTION lässt libcurl einen gestreamten Request-Body bei Redirects zurückspulen.
• PDO_PGSQL: Pdo\Pgsql::ATTR_CHUNK_SIZE holt Zeilen in Blöcken (libpq 17).
• Stream-Sockets akzeptieren die Context-Optionen so_keepalive, tcp_keepidle, tcp_keepintvl, tcp_keepcnt, so_linger und so_reuseaddr.
• openssl_sign()/openssl_verify() nehmen ein $salt_length für RSA-PSS; openssl_x509_parse() listet kritische Extensions.
• ZipArchive::openString() und closeString() arbeiten auf Archiven im Speicher.
• gmp_prevprime() und das seitenkanalresistente gmp_powm_sec().
• Referenz-Zuweisung in eine WeakMap verlangt nicht mehr, dass der Schlüssel existiert.
• ini_get_all() liefert je Direktive builtin_default_value.
• Der CLI-Entwicklungsserver beantwortet die HTTP-Methode QUERY.
• array_filter() bekommt die explizite Konstante ARRAY_FILTER_USE_VALUE; finfo_file() arbeitet auf entfernten Streams.

Sichere Session-Defaults

RFC: session_security_defaults

Drei INI-Defaults ändern sich: session.use_strict_mode=1 verwirft Session-IDs, die der Server nicht vergeben hat, session.cookie_httponly=1 versteckt das Cookie vor JavaScript und session.cookie_samesite=Lax hält es aus Cross-Site-POSTs heraus.

Das ist die 8.6-Änderung, die am ehesten unbemerkt in Produktion ankommt. Frameworks setzen diese Werte seit Jahren, reines PHP oft nicht. Session-Übergaben zwischen Subdomains, JavaScript, das PHPSESSID liest, und Cross-Site-Formulare brechen; für jeden Fall gibt es ein explizites Opt-out in der php.ini.

; PHP 8.6 ships these as built-in defaults (were 0 / 0 / unset)
session.use_strict_mode = 1     ; unknown session IDs are rejected (fixation)
session.cookie_httponly = 1     ; document.cookie can no longer read it
session.cookie_samesite = Lax   ; not sent on cross-site POSTs

; Only if you really depend on the old behaviour:
; session.cookie_samesite = None  (requires session.cookie_secure = 1)

Funktionsargumente in Fehlermeldungen

RFC: display_error_function_args

Mit error_include_args=1 enthalten Warnings eingebauter Funktionen die Argumente des Aufrufs, über dieselbe Mechanik wie Exception-Backtraces: #[\SensitiveParameter]-Werte bleiben maskiert, zend.exception_string_param_max_len kürzt lange Strings.

chmod(): Operation not permitted sagt nichts; chmod('/var/app/cache', 511) schon. Die Einstellung ist in der Beta wegen Log-Größe und PII-Bedenken standardmäßig aus, also bewusst zuerst im Staging aktivieren.

$ php -d error_include_args=1 -r 'chmod("/var/app/cache", 0777);'
Warning: chmod('/var/app/cache', 511): Operation not permitted in ...

# #[\SensitiveParameter] values stay masked, long strings are cut
# by zend.exception_string_param_max_len; the INI defaults to 0 (off)

php://filter-Ketten auf 16 gedeckelt

RFC: limit-maximum-number-of-filter-chains

Eine php://filter-URL mit mehr als 16 Filtern erzeugt jetzt E_DEPRECATED; das Limit lässt sich pro Context über filter.max_filter_count anheben, stream_filter_append() bleibt unbegrenzt.

Ketten aus convert.iconv- und base64-Filtern sind das Standardwerkzeug, um eine Local File Inclusion zu Remote Code Execution zu machen. Legitimer Code stapelt selten mehr als drei Filter, also entfernt die Deckelung die Exploit-Klasse ohne einen INI-Schalter, den man vergessen könnte.

// Still fine: two filters
file_get_contents('php://filter/string.toupper|string.rot13/resource=data://text/plain,hello');

// 17+ filters in one URL (the LFI-to-RCE gadget) now emits E_DEPRECATED,
// a later version turns it into an error. Raise the cap only on purpose:
$ctx = stream_context_create(['php' => ['filter.max_filter_count' => 32]]);

return aus __construct()/__destruct() ist deprecated

RFC: deprecate-return-value-from-construct

return mit Wert in Konstruktor oder Destruktor erzeugt eine Compile-Zeit-Deprecation, ebenso yield, das beide zu Generatoren machen würde. Ein nacktes return; zum Überspringen des Rests bleibt erlaubt.

Konstruktoren können keinen Rückgabetyp deklarieren, also hielt nichts return $this; auf; ein Audit der Top-4000-Composer-Pakete fand 77 solcher Statements. PHP 9 macht aus der Deprecation einen Fehler.

class Connection
{
    public function __construct()
    {
        return $this;   // Deprecated: Returning a value from a constructor is deprecated
    }

    public function __destruct()
    {
        if (!$this->open) {
            return;     // bare "return;" stays legal
        }
    }
}

mb_ereg*() deprecated: Oniguruma ist End-of-Life

RFC: eol-oniguruma

Alle mbregex-Funktionen (mb_ereg, mb_ereg_replace, mb_split, mb_eregi, …), die INI-Einstellungen mbstring.regex_* und MB_ONIGURUMA_VERSION sind in 8.6 deprecated und für 9.0 zur Entfernung vorgesehen, weil die Oniguruma-Bibliothek seit April 2025 nicht mehr gepflegt wird.

PCRE mit u-Modifier deckt UTF-8-Fälle ab. Code, der auf Multibyte-Regex jenseits von UTF-8 baut, braucht das externe mb_onig-Paket des RFC-Autors. Jetzt nach mb_ereg und mb_split greppen; in den Top-Composer-Paketen fanden sich 147 Vorkommen.

// Deprecated in 8.6, removed in 9.0 (Oniguruma is unmaintained since 2025-04)
$parts = mb_split('\s+', $text);
$clean = mb_ereg_replace('[^\w]', '', $text);

// PCRE with the /u modifier covers the same ground
$parts = preg_split('/\s+/u', $text);
$clean = preg_replace('/[^\w]/u', '', $text);

Mindestversionen und Plattformen

RFC: min_supported_versions_php_8_6 27–2 angenommen 26–0 angenommen

Builds aus Git brauchen autoconf 2.71, persistente MySQL-Verbindungen verlangen MySQL 5.7.3 oder MariaDB 10.2.4 für COM_RESET_CONNECTION, und die offiziellen Windows-Builds wechseln auf Visual Studio 2026, OpenSSL 4 und libxml2 2.15.

• autoconf 2.71 (nur für Builds aus Git; Release-Tarballs liefern configure mit)
• MySQL ≥ 5.7.3 / MariaDB ≥ 10.2.4 für persistente Verbindungen in mysqlnd und PDO
• Windows: VS-2026-Toolchain (VS18), OpenSSL 4, libxml2 2.15.3
• PHP_OS_FAMILY kennt den Wert AIX

Performance

Mehrere Muster kompilieren jetzt zu günstigeren Opcodes, ZTS-Builds wurden durchgehend schneller, und der JIT erreicht Apple Silicon in Thread-Builds.

• printf() nur mit %s und %d kompiliert zu String-Interpolation.
• array_map() mit First-Class-Callable oder Partial Application kompiliert zu einer foreach-Schleife ohne Zwischen-Closures.
• Argumente an bekannte Konstruktoren (new self()) werden effizienter übergeben.
• Die TAILCALL-VM ist schneller und unter Windows mit Clang 19+ verfügbar.
• JIT für ZTS-Builds auf Apple Silicon; allgemeine ZTS-Beschleunigung.
• Schnellere str_ends_with(), str_split(), array_fill_keys(), array_intersect(), array_sum()/array_product() auf Int-Arrays, array_unshift(), array_walk(), json_encode() mit Pretty Print.

// Both lines compile to the same string interpolation, no function call
printf("%s has %d items\n", $name, $count);
echo "$name has $count items\n";

// First-class callables and partials in array_map() become a plain loop:
// no intermediate Closure, no userland-callback overhead, JIT-friendly
$upper = array_map(strtoupper(...), $names);
$prefixed = array_map(str_replace('_', '-', ?), $keys);

SNMP

RFC: snmp_improvements_2026

AES192/AES256-Sicherheitsprotokolle für SNMPv3, wo net-snmp sie unterstützt, snmp_init_mib() zum Zurücksetzen des MIB-Baums sowie neue Steuerung von MIB-Parsing und Ausgabe (snmp_set_mib_option(), snmp_set_output_option(), OID- und String-Ausgabeformate).