Application partielle de fonctions

RFC: partial_function_application_v2, partial_function_application_optional_placeholder

Un ? à la place d’un argument transforme l’appel en Closure pour le reste. Les placeholders nommés réordonnent les paramètres, ... récupère tout ce qui n’a pas encore été fourni, et la Closure obtenue conserve types, valeurs par défaut et passage par référence pour la réflexion.

C’est la moitié manquante des first-class callables de 8.1 et le partenaire naturel de l’opérateur pipe de 8.5. array_map(str_replace('a', 'b', ?), $list) remplace une ligne de fonction fléchée, et l’analyse statique voit la vraie signature. Une RFC complémentaire a rendu chaque ? obligatoire : l’arité que vous écrivez est celle que vous obtenez.

// 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}

Valeurs par défaut pour les propriétés readonly

RFC: readonly_property_defaults 24–0 adopté

Une propriété readonly peut désormais déclarer une valeur par défaut ; cette valeur compte comme l’unique initialisation. Avec les propriétés d’interface de 8.4, cela donne des constantes contractuelles par classe sans affectation dans le constructeur.

La RFC readonly d’origine jugeait les valeurs par défaut « pas particulièrement utiles ». Les propriétés d’interface ont changé la donne : une valeur readonly par défaut satisfait un contrat { get; } sans boilerplate. Attention : une affectation dans le constructeur est désormais une modification et lève une erreur, et unset() sur une telle propriété échoue.

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

Écriture de propriétés sur des objets tenus par des constantes

RFC: const_object_property_write 17–2 adopté

Les objets dans les constantes existent depuis 8.1, mais toute écriture comme CONST->prop = 1 mourait avec « Cannot use temporary expression in write context ». PHP 8.6 lève cette restriction pour les affectations de propriétés, les opérateurs composés, les incréments, isset(), unset() et le passage par référence.

La liaison de la constante reste immuable ; seul l’état de l’objet change, comme les objets se comportent partout ailleurs. Les constantes tableau ne bougent pas (copy-on-write). Effet de bord : écrire dans la propriété d’un cas d’enum lève désormais l’erreur readonly habituelle au lieu d’une erreur fatale à la compilation.

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 adopté 30 multiplyBy, divideBy, neg… · 2 mul, divBy, neg, abs tranché

Une durée « chronomètre », finale et readonly, avec une précision à la nanoseconde : fabriques des secondes aux nanosecondes et depuis des chaînes ISO 8601, add/sub/multiplyBy/divideBy, opérateurs de comparaison et une plage protégée contre le dépassement d’environ 292 ans.

Timeouts, backoff et planification étaient des int dans une unité quelconque ou des flottants fragiles. DateInterval transporte des unités calendaires impossibles à convertir en secondes de façon fiable. Duration est sûre par construction et sert déjà de type de timeout à la nouvelle API de polling ; d’autres API internes suivront. sleep() et consorts prennent toujours un 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] sur les constantes de classe

RFC: override_constants

L’attribut introduit pour les méthodes en 8.3 et étendu aux propriétés en 8.5 couvre désormais les constantes de classe et les cas d’enum. Le compilateur signale une erreur si rien n’est réellement surchargé.

Surcharger une constante parente par accident est un bug silencieux classique. Marquer l’intention sécurise les refactorings : renommez la constante parente et l’enfant ne compile plus au lieu de définir discrètement une nouvelle constante.

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() sur les enums

RFC: debugable-enums

Les enums peuvent implémenter __debugInfo() ; var_dump() garde l’en-tête enum(Foo::Bar) et ajoute ce que la méthode retourne.

La sortie des enums dans les dumps et les débogueurs était figée et laconique. Les backed enums aux valeurs parlantes, ou les cas qui pointent vers une configuration, peuvent maintenant s’expliquer. __toString() sur les enums a été discuté puis écarté au profit de ce changement plus étroit.

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"
// }

Commentaires de documentation sur les paramètres

RFC: parameter-doccomments

Un commentaire /** … */ placé avant ou après un paramètre est conservé par le moteur et renvoyé par le nouveau ReflectionParameter::getDocComment().

La documentation des paramètres n’a plus à répéter nom et type dans une ligne @param au-dessus de la fonction, où elle se désynchronise sans bruit. Les frameworks pilotés par attributs et les générateurs d’API lisent le texte directement par réflexion.

/** 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 */

Les closures sans état sont mises en cache

RFC: closure-optimizations

Une closure statique qui ne capture aucune variable et ne déclare aucune variable static est créée une fois puis réutilisée. Deux closures de ce type issues du même emplacement source sont désormais le même objet.

Les chemins chauds qui recréent la même closure à chaque itération n’allouent plus. La seconde partie de la RFC, inférer static pour les closures qui n’utilisent jamais $this, a été retirée après le vote à cause d’un cas limite avec les callables sous forme de chaîne ; marquez vos closures static vous-même pour le bénéfice complet.

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) renvoie la valeur si elle est dans les bornes, sinon la borne la plus proche. La fonction accepte tout ce qui est comparable, chaînes et objets DateTime compris, et lève un ValueError si $min dépasse $max ou si une borne vaut NAN.

L’idiome max($min, min($max, $v)) cache deux bugs : des bornes inversées et un NAN qui passe en silence. La version native vérifie les deux et va légèrement plus vite que le ternaire en userland.

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

Erreurs de flux structurées

RFC: stream_errors

Un contexte de flux peut basculer la gestion d’erreurs vers des exceptions ou une collecte silencieuse : error_mode (Error, Exception, Silent), error_store et un callback error_handler. Les erreurs arrivent sous forme d’objets StreamError avec un cas de l’enum StreamErrorCode, le nom du wrapper, la sévérité et le chemin concerné.

Jusqu’ici file_get_contents() et consorts signalaient l’échec par des warnings à intercepter avec un gestionnaire d’erreurs et à analyser comme du texte. Avec StreamErrorMode::Exception, une ouverture ratée est une StreamException aux codes lisibles par la machine ; les valeurs par défaut ne bougent pas, rien ne change sans votre demande.

$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)

API de polling (Io\Poll)

RFC: poll_api

Une API de multiplexage native au-dessus d’epoll, kqueue, event ports, WSAPoll ou poll() : Io\Poll\Context surveille des handles pour les événements Read, Write, Error et HangUp, gère les modes one-shot et edge-triggered et renvoie depuis wait() les watchers déclenchés.

stream_select() est en O(n), plafonné à 1024 descripteurs sur bien des systèmes et ignore les noyaux modernes. Les boucles d’événements comme Revolt, ReactPHP ou AMPHP peuvent tourner sur un backend intégré au lieu d’ext-uv ou ext-event, et les runtimes façon FrankenPHP obtiennent une API interne partagée. Seules les ressources de flux sont pollables dans cette première version.

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 : builders et détection de type

RFC: uri_followup

Uri\Rfc3986\UriBuilder et Uri\WhatWg\UrlBuilder assemblent une URI dans un seul objet et valident au build() ; getUriType() distingue les URI absolues des références de chemin et de réseau, getHostType() indique IPv4, IPv6, domaine ou hôte opaque, et isSpecialScheme() dit si les règles WHATWG des schémas spéciaux s’appliquent.

Les classes URI de 8.5 n’offraient que des withers immuables : un objet alloué par étape et une dépendance à l’ordre des appels. Le builder supprime les deux. L’aide à l’encodage pourcent de la même RFC n’a pas encore atterri dans la bêta.

// 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

Un enum global non adossé avec les cas Ascending et Descending, pensé comme le type unique de sens de tri sur lequel PHP, frameworks et bibliothèques convergent.

Doctrine, les query builders et chaque ORM livrent leur propre enum Order. Un type partagé rend les signatures interopérables ; une union avec les anciens drapeaux string ou int garde les API existantes compatibles pendant la migration.

// 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() et isWritable()

RFC: isreadable-iswriteable

Les deux méthodes répondent si une lecture ou une écriture réussirait depuis une portée donnée, éventuellement pour un objet concret. Elles comprennent readonly, la visibilité asymétrique, les hooks et les accesseurs magiques, ce qu’isPublic() n’a jamais fait.

Depuis readonly (8.1) et private(set) (8.4), public ne signifie plus modifiable. Sérialiseurs, hydrateurs et mappers devaient réimplémenter les règles du moteur ; ils les demandent maintenant au moteur.

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)

Modificateurs de boutisme pour pack()/unpack()

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

Les modificateurs < et > à la Perl fonctionnent désormais sur les codes entiers s, l, q, S, L, Q et sur les codes flottants f et d. Les appliquer à un code au boutisme intrinsèque lève un ValueError.

Lire un int32 signé little-endian demandait trois appels unpack() et des décalages de bits. Les parseurs de protocoles binaires et de formats de fichiers tiennent en une chaîne de format. Attention au nommage : unpack('s<value') produit désormais la clé value, pas <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

Échappe et entoure une chaîne de guillemets simples en une étape, le pendant mysqli de PDO::quote(). Disponible en mysqli::quote_string() et mysqli_quote_string().

real_escape_string() n’a jamais été correct qu’entre guillemets simples ; avec des guillemets doubles et NO_BACKSLASH_ESCAPES, c’était une faille d’injection. La nouvelle fonction supprime le quoting manuel là où les requêtes préparées ne sont pas une option, comme dans les query builders qui doivent produire du SQL complet.

// 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!'

Reprise de session TLS, PSK et 0-RTT

RFC: tls_session_resumption_api

Les contextes de flux gagnent session_data, session_new_cb, session_cache et les options associées avec un objet Openssl\Session exportable et importable ; psk_client_cb/psk_server_cb activent les clés pré-partagées externes, et early_data ajoute le 0-RTT de TLS 1.3.

Chaque requête PHP recommençait un handshake TLS complet. Persister la session dans Redis ou APCu économise un aller-retour par appel HTTPS sortant, et les serveurs écrits en PHP peuvent adosser leur cache de sessions à n’importe quel stockage.

// 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() et plus

RFC: grapheme_strrev, getdisplaykeyword_and_getdisplaykeywordvalue

grapheme_strrev() inverse par grappe de graphèmes, les séquences d’emoji et les diacritiques restent intacts. Locale::getDisplayKeyword() et getDisplayKeywordValue() localisent les mots-clés de locale, IntlNumberRangeFormatter formate des plages numériques, SpoofChecker apprend les confusions bidirectionnelles et IntlDatePatternGenerator renvoie des squelettes.

L’extension intl continue de combler ses écarts avec ICU. La plupart de ces ajouts sont petits, mais la paire display-keyword complète une famille incomplète depuis PHP 5.3.

// 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);

Ajouts plus petits à connaître

Le changelog est long ; voici les entrées les plus susceptibles d’apparaître dans du code applicatif.

• json_last_error_msg() et JsonException indiquent désormais l’offset du token fautif.
• curl_getinfo() rapporte size_delivered, et CURLOPT_SEEKFUNCTION laisse libcurl rembobiner un corps de requête streamé lors des redirections.
• PDO_PGSQL : Pdo\Pgsql::ATTR_CHUNK_SIZE récupère les lignes par blocs avec libpq 17.
• Les sockets de flux acceptent les options de contexte so_keepalive, tcp_keepidle, tcp_keepintvl, tcp_keepcnt, so_linger et so_reuseaddr.
• openssl_sign()/openssl_verify() prennent un $salt_length pour RSA-PSS ; openssl_x509_parse() liste les extensions critiques.
• ZipArchive::openString() et closeString() travaillent sur des archives en mémoire.
• gmp_prevprime() et gmp_powm_sec(), résistant aux canaux auxiliaires.
• L’affectation par référence dans une WeakMap n’exige plus que la clé existe.
• ini_get_all() expose builtin_default_value par directive.
• Le serveur de développement CLI répond à la méthode HTTP QUERY.
• array_filter() gagne la constante explicite ARRAY_FILTER_USE_VALUE ; finfo_file() fonctionne sur les flux distants.

Sessions sécurisées par défaut

RFC: session_security_defaults

Trois valeurs INI par défaut changent : session.use_strict_mode=1 rejette les identifiants de session que le serveur n’a pas émis, session.cookie_httponly=1 cache le cookie à JavaScript et session.cookie_samesite=Lax l’empêche de voyager avec les POST inter-sites.

C’est le changement de 8.6 le plus susceptible d’atteindre la production sans être remarqué. Les frameworks fixent ces valeurs depuis des années, le PHP nu souvent pas. Les passages d’identifiant entre sous-domaines, le JavaScript qui lit PHPSESSID et les formulaires inter-sites cassent ; chaque cas a un opt-out explicite dans 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)

Arguments de fonction dans les messages d’erreur

RFC: display_error_function_args

Avec error_include_args=1, les warnings levés par les fonctions internes incluent les arguments de l’appel, via la même mécanique que les backtraces d’exceptions : les valeurs #[\SensitiveParameter] restent masquées et zend.exception_string_param_max_len tronque les longues chaînes.

chmod(): Operation not permitted ne dit rien ; chmod('/var/app/cache', 511) dit tout. Le réglage est désactivé par défaut dans la bêta pour des raisons de volume de logs et de données personnelles ; activez-le d’abord en staging, délibérément.

$ 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)

Chaînes php://filter plafonnées à 16

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

Une URL php://filter de plus de 16 filtres émet désormais E_DEPRECATED ; la limite se relève par contexte via filter.max_filter_count, et stream_filter_append() reste illimité.

Les chaînes de filtres convert.iconv et base64 sont l’outil standard pour transformer une inclusion de fichier local en exécution de code à distance. Le code légitime empile rarement plus de trois filtres : le plafond supprime la classe d’exploit sans interrupteur INI à oublier.

// 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 depuis __construct()/__destruct() est déprécié

RFC: deprecate-return-value-from-construct

Un return avec valeur dans un constructeur ou un destructeur émet une dépréciation à la compilation, tout comme yield qui en ferait un générateur. Un return; nu pour sauter la suite du corps reste légal.

Les constructeurs ne peuvent pas déclarer de type de retour, rien n’empêchait donc return $this; de s’installer ; un audit des 4000 principaux paquets Composer a trouvé 77 instructions de ce genre. PHP 9 transformera la dépréciation en erreur.

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*() déprécié : Oniguruma en fin de vie

RFC: eol-oniguruma

Toutes les fonctions mbregex (mb_ereg, mb_ereg_replace, mb_split, mb_eregi, …), les réglages INI mbstring.regex_* et MB_ONIGURUMA_VERSION sont dépréciés en 8.6 et prévus pour suppression en 9.0, la bibliothèque Oniguruma n’étant plus maintenue depuis avril 2025.

PCRE avec le modificateur u couvre les cas UTF-8. Le code qui dépend d’expressions régulières multi-octets hors UTF-8 aura besoin du paquet externe mb_onig maintenu par l’auteur de la RFC. Cherchez mb_ereg et mb_split dès maintenant ; 147 occurrences ont été trouvées dans les principaux paquets Composer.

// 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);

Versions minimales et plateformes

RFC: min_supported_versions_php_8_6 27–2 adopté 26–0 adopté

Compiler depuis git exige autoconf 2.71, les connexions MySQL persistantes demandent MySQL 5.7.3 ou MariaDB 10.2.4 pour COM_RESET_CONNECTION, et les builds Windows officielles passent à Visual Studio 2026, OpenSSL 4 et libxml2 2.15.

• autoconf 2.71 (uniquement pour les builds depuis git ; les archives de release livrent configure)
• MySQL ≥ 5.7.3 / MariaDB ≥ 10.2.4 pour les connexions persistantes dans mysqlnd et PDO
• Windows : toolchain VS 2026 (VS18), OpenSSL 4, libxml2 2.15.3
• PHP_OS_FAMILY gagne la valeur AIX

Performance

Plusieurs motifs compilent désormais vers des opcodes moins coûteux, les builds ZTS ont accéléré partout et le JIT atteint Apple Silicon dans les builds threadées.

• printf() avec seulement %s et %d compile en interpolation de chaîne.
• array_map() avec un first-class callable ou une application partielle compile en boucle foreach sans Closure intermédiaire.
• Les arguments des constructeurs connus (new self()) sont transmis plus efficacement.
• La VM TAILCALL est plus rapide et disponible sous Windows avec Clang 19+.
• JIT pour les builds ZTS sur Apple Silicon ; accélérations ZTS générales.
• str_ends_with(), str_split(), array_fill_keys(), array_intersect(), array_sum()/array_product() sur tableaux d’entiers, array_unshift(), array_walk() et json_encode() en pretty print plus rapides.

// 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

Protocoles de sécurité AES192/AES256 pour SNMPv3 quand net-snmp les supporte, snmp_init_mib() pour réinitialiser l’arbre MIB, et de nouveaux contrôles d’analyse et de sortie MIB (snmp_set_mib_option(), snmp_set_output_option(), formats de sortie OID et chaîne).