PHP 8.6 passe en Beta : parmi les petites nouveautés que je vais vraiment utiliser, il y en a une toute simple : clamp().

Son objectif est très simple : forcer une valeur à rester comprise entre une borne minimale et une borne maximale.

$score = clamp($score, 0, 100);

Si $score vaut 50, la fonction retourne 50. S’il vaut -20, elle retourne 0. S’il vaut 250, elle retourne 100.

Ce n’est pas une révolution du langage. Pourtant, c’est exactement le genre de petite amélioration que l’on finit par utiliser partout parce qu’elle rend immédiatement le code plus lisible et l’intention beaucoup plus explicite.

PHP 8.6 : date de sortie et disponibilité

PHP 8.6 est actuellement encore en développement.

Après plusieurs versions Alpha durant l’été 2026, la première Beta est prévue pour le 13 août 2026. Les différentes Release Candidates doivent ensuite se succéder à partir de septembre, avant une sortie stable actuellement programmée pour le 19 novembre 2026.

Comme toujours avec une version de PHP encore en développement, ce calendrier peut évoluer. Les versions Alpha, Beta et Release Candidate sont destinées aux tests et ne doivent pas être considérées comme des versions de production.

clamp() est cependant déjà implémentée dans PHP 8.6 et fait partie des fonctionnalités prévues pour cette version.

Le problème avant PHP 8.6

Limiter une valeur entre deux bornes est un besoin extrêmement courant.

Prenons un pourcentage qui doit obligatoirement rester compris entre 0 et 100.

Avant PHP 8.6, une écriture fréquente consistait à combiner min() et max() :

$score = max(0, min(100, $score));

Le code fonctionne parfaitement, mais il demande un petit effort de lecture. Il faut comprendre l’imbrication des deux fonctions avant de saisir l’intention.

On peut également écrire la logique explicitement :

if ($score < 0) {
    $score = 0;
}

if ($score > 100) {
    $score = 100;
}

Cette version est facile à comprendre, mais elle ajoute plusieurs lignes pour exprimer une règle extrêmement simple : on veux que cette valeur reste entre 0 et 100.

Avec PHP 8.6, cette intention devient directement visible :

$score = clamp($score, 0, 100);

C’est probablement le principal intérêt de clamp().

Le gain n’est pas uniquement le nombre de caractères économisés. Le nom de la fonction décrit directement ce que le développeur cherche à faire.

Comment fonctionne clamp() dans PHP 8.6 ?

La signature de la fonction est la suivante :

clamp(mixed $value, mixed $min, mixed $max): mixed

Elle reçoit donc trois paramètres : la valeur à contrôler, la borne minimale et la borne maximale.

Si la valeur se trouve déjà dans l’intervalle, elle est retournée telle quelle.

echo clamp(50, 0, 100);

Résultat :

50

Si elle est inférieure à la borne minimale, clamp() retourne le minimum :

echo clamp(-20, 0, 100);

Résultat :

0

Et si elle dépasse la borne maximale, la fonction retourne le maximum :

echo clamp(250, 0, 100);

Résultat :

100

Autrement dit, cette écriture :

$value = max($min, min($max, $value));

peut désormais devenir :

$value = clamp($value, $min, $max);

L’intention est immédiatement identifiable.

Des cas d’usage très courants

L’intérêt de clamp() apparaît surtout lorsque l’on regarde le nombre de situations dans lesquelles une application doit manipuler une valeur bornée.

Pour un pourcentage :

$progress = clamp($progress, 0, 100);

Pour empêcher une pagination de sortir d’un intervalle autorisé :

$page = clamp($page, 1, $maxPage);

Pour une opacité :

$opacity = clamp($opacity, 0.0, 1.0);

Ou encore pour normaliser une remise :

$discount = clamp($discount, 0, 100);

On retrouve le même principe dans les quotas, les scores, certaines valeurs de configuration, des limites métier ou encore la normalisation de données.

clamp() permet alors d’exprimer la contrainte directement au même endroit que la valeur.

Exemple concret : avant et après PHP 8.6

Prenons un petit calculateur chargé de s’assurer qu’une remise reste comprise entre 0 et 100 %.

Avant PHP 8.6 :

final class DiscountCalculator
{
    public function normalize(int $discount): int
    {
        return max(0, min(100, $discount));
    }
}

Avec PHP 8.6 :

final class DiscountCalculator
{
    public function normalize(int $discount): int
    {
        return clamp($discount, 0, 100);
    }
}

Le comportement métier n’a pas changé.

Ce qui change, c’est la vitesse avec laquelle un développeur comprend le code.

Dans la deuxième version, il n’est plus nécessaire de décoder l’enchaînement de max() et min(). Le code dit directement : limiter $discount entre 0 et 100.

Sur une ligne isolée, le gain peut sembler faible. À l’échelle d’une application et de plusieurs années de maintenance, ce genre de détail participe pourtant fortement à la lisibilité générale du code.

clamp() fonctionne aussi avec les floats

La fonction n’est évidemment pas réservée aux entiers.

On peut par exemple limiter un nombre flottant :

$value = clamp(3.14, 0.0, 10.0);

La valeur étant déjà comprise entre les deux bornes, le résultat reste :

3.14

Avec une valeur supérieure au maximum :

$value = clamp(15.7, 0.0, 10.0);

le résultat correspond à la borne maximale :

10.0

Pour la majorité des usages applicatifs, int et float seront probablement les types les plus naturels à utiliser avec cette fonction.

Attention aux types comparés

La signature de clamp() utilise volontairement le type mixed :

clamp(mixed $value, mixed $min, mixed $max): mixed

La fonction n’est donc techniquement pas limitée aux nombres.

C’est un point important, car clamp() utilise les règles habituelles de comparaison de PHP. Mélanger des types différents peut donc produire du code beaucoup moins évident à comprendre.

Il est par exemple possible de rencontrer des appels impliquant des chaînes, des booléens, des tableaux ou d’autres valeurs comparables, mais cela ne signifie pas qu’il soit souhaitable de le faire dans du code métier courant.

En pratique, on privilégierais des valeurs du même type et, dans la majorité des cas, des int ou des float.

L’objectif de clamp() est justement d’améliorer la lisibilité. Introduire volontairement des comparaisons implicites complexes irait à l’encontre de cet avantage.

Que se passe-t-il si $min est supérieur à $max ?

Les bornes doivent évidemment former un intervalle cohérent.

Cet appel est invalide :

clamp(10, 100, 0);

La borne minimale étant supérieure à la borne maximale, PHP déclenche une ValueError.

C’est une différence intéressante par rapport à certaines implémentations artisanales : la fonction native ne se contente pas de réduire la quantité de code, elle apporte également ses propres validations.

Et avec NAN ?

PHP 8.6 définit également explicitement le comportement de clamp() avec NAN.

Utiliser NAN comme borne minimale ou maximale provoque une ValueError. Si NAN est en revanche utilisé comme valeur à limiter, il est retourné tel quel.

Ce cas restera assez marginal dans la majorité des applications web classiques, mais il montre pourquoi une véritable implémentation native est préférable à une simple combinaison de min() et max() lorsque l’on cherche à reproduire exactement le comportement de la fonction.

Un polyfill pour PHP inférieur à 8.6 ?

Si une application doit proposer une syntaxe similaire avant sa migration vers PHP 8.6, on peut facilement créer une petite fonction pour les usages numériques classiques :

if (!function_exists('clamp')) {
    function clamp(int|float $value, int|float $min, int|float $max): int|float
    {
        if ($min > $max) {
            throw new ValueError(
                '$min must be less than or equal to $max'
            );
        }

        if ($value < $min) {
            return $min;
        }

        if ($value > $max) {
            return $max;
        }

        return $value;
    }
}

On préfère volontairement limiter cet exemple aux int et float.

Il reproduit le besoin métier le plus courant de clamp(), mais il ne cherche pas à réimplémenter l’intégralité des règles de comparaison et des cas particuliers de la fonction native de PHP 8.6.

À partir du moment où l’application utilise réellement PHP 8.6, mieux vaut évidemment supprimer ce polyfill et utiliser directement l’implémentation du langage.

Pourquoi une fonction aussi petite est intéressante

clamp() n’ajoute aucune nouvelle possibilité fondamentale à PHP.

Tout ce qu’elle permet de faire était déjà réalisable auparavant.

C’est justement ce qui rend cette évolution intéressante.

Un langage mature ne progresse pas uniquement grâce à de nouvelles fonctionnalités spectaculaires. Il évolue également en standardisant des patterns que les développeurs réécrivent constamment.

Au lieu d’avoir plusieurs variantes :

max($min, min($max, $value));

ou :

if ($value < $min) {
    $value = $min;
}

if ($value > $max) {
    $value = $max;
}

on dispose maintenant d’une intention commune :

clamp($value, $min, $max);

Un développeur qui rencontre cette ligne sait immédiatement ce qu’elle signifie.

C’est moins de code à interpréter, moins de logique répétitive et une convention supplémentaire partagée par l’écosystème PHP.

Conclusion

Parmi les nouveautés de PHP 8.6, clamp() fait partie de ces petites fonctions dont l’intérêt devient évident dès qu’on commence à les utiliser.

Avant PHP 8.6 :

$value = max($min, min($max, $value));

Avec PHP 8.6 :

$value = clamp($value, $min, $max);

Le résultat est le même, mais l’intention est beaucoup plus claire.

Et c’est précisément ce que j’attends de ce genre d’évolution du langage : pas nécessairement permettre de faire quelque chose d’impossible auparavant, mais permettre de l’exprimer de manière plus évidente.

PHP 8.6 est actuellement attendu en version stable pour novembre 2026. D’ici là, clamp() fait partie des nouveautés que les développeurs peuvent déjà commencer à tester pour préparer leurs futures migrations.

Sources

• PHP RFC — clamp v2
• PHP 8.6 Preparation Tasks / Release Schedule