IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Le langage de programmation PHP 8.6 est disponible, avec de nouvelles fonctionnalités incluant l'application partielle de fonction, une nouvelle classe Duration, et une API de polling

Le , par Alex

0PARTAGES

3  0 
Le langage de programmation PHP 8.6 est disponible. C'est une mise à jour majeure du langage PHP, avec de nouvelles fonctionnalités incluant l'application partielle de fonction, une nouvelle classe Duration, une API de polling et une nouvelle fonction clamp().

PHP est un langage de script polyvalent destiné au développement web. Il a été créé par le programmeur dano-canadien Rasmus Lerdorf en 1993 et publié en 1995. L'implémentation de référence de PHP est désormais développée par le PHP Group. À l’origine, PHP était l’abréviation de « Personal Home Page », mais il désigne désormais l’acronyme récursif « PHP : Hypertext Preprocessor ». 

Le code PHP est généralement traité sur un serveur web par un interpréteur PHP implémenté sous la forme d’un module, d’un démon ou d’un exécutable CGI (Common Gateway Interface). Sur un serveur web, le résultat du code PHP interprété et exécuté — qui peut être n'importe quel type de données, tel que du code HTML généré ou des données d'image binaires — peut constituer tout ou partie d'une réponse HTTP. Divers systèmes de modèles web, systèmes de gestion de contenu web et frameworks web peuvent être utilisés pour orchestrer ou faciliter la génération de cette réponse. PHP peut être utilisé pour des tâches de programmation en dehors du contexte web, bien que cette utilisation soit rare. Le code PHP peut également être exécuté directement depuis la ligne de commande.

Récemment, la version 8.6 du langage de programmation PHP est disponible, avec l'application partielle des fonctions, une classe `Duration`, une API de sondage, des modifications concernant les erreurs de flux et d'autres mises à jour du langage.


Voici les fonctionnalités clés de PHP 8.6 :

Application partielle de fonction

Permet de fournir à l'avance une partie des arguments d'une fonction, en utilisant les marqueurs ? et ... pour les autres. Le résultat est une Closure, et la fonction n'est appelée qu'une fois les arguments restants transmis.

Code : Sélectionner tout
1
2
3
4
5
6
$versions = ['8.4', '8.5', '8.6', '8.7', '9.0'];
 
$supportsPfa = array_filter(
    $versions,
    version_compare(?, '8.6', '>='),
);


Nouvelle classe \Time\Duration:

La classe Duration représente un temps écoulé, tel que mesuré par un chronomètre. Sa représentation est indépendante de tout instant et de tout fuseau horaire, et peut couvrir plus de 250 ans avec une précision à la nanoseconde. Elle convient donc parfaitement pour représenter de manière expressive des délais d'expiration ou des mesures de benchmark.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
use Time\Duration;
 
function backoff(
    Duration $baseDelay,
    Duration $step,
    int $attempt,
): void {
    $delay = $baseDelay->add($step->multiplyBy(2 ** $attempt));
 
    // Durations are comparable, so min() works directly.
    $delay = min($delay, Duration::fromSeconds(30));
 
    time_nanosleep($delay->seconds, $delay->nanoseconds);
}
 
backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    $attempt,
);
 
// Preconfigure the delays using Partial Function Application.
$waitBeforeRetry = backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    attempt: ?,
);
$waitBeforeRetry($attempt);
API de polling

La nouvelle API Io\Poll surveille efficacement un grand nombre de flux simultanément en utilisant le meilleur mécanisme disponible sur chaque plateforme (epoll, kqueue, event ports ou WSAPoll), sans les limites de scalabilité de stream_select(). Elle est conçue comme une base commune sur laquelle les bibliothèques de boucle d'événements, telles que ReactPHP et AMPHP, peuvent s'appuyer.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
use Io\Poll\{Context, Event};
 
$server = stream_socket_server('tcp://0.0.0.0:8080');
 
// Automatically uses epoll, kqueue, event ports, or WSAPoll
$poll = new Context();
$poll->add(new StreamPollHandle($server), [Event::Read]);
 
while (true) {
    foreach ($poll->wait() as $watcher) {
        $stream = $watcher->getHandle()->getStream();
 
        if ($stream === $server) {
            $client = stream_socket_accept($server);
            $poll->add(
                new StreamPollHandle($client),
                [Event::Read],
            );
            continue;
        }
 
        $data = fread($stream, 8192);
 
        if ($data === '' || $data === false) {
            $watcher->remove();
            fclose($stream);
        } else {
            fwrite($stream, $data);
        }
    }
}
Gestion des erreurs des flux

Les opérations sur les flux peuvent désormais être configurées pour lancer une StreamException ou pour échouer silencieusement, au lieu d'émettre des avertissements. Les erreurs sont signalées sous forme d'objets StreamError structurés, avec un cas de l'énumération StreamErrorCode, le nom du wrapper et le chemin ou l'URL concerné. Elles peuvent aussi être récupérées plus tard avec stream_last_errors() ou transmises à un gestionnaire d'erreurs personnalisé.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$context = stream_context_create([
    'stream' => [
        'error_mode' => StreamErrorMode::Exception,
    ],
]);
 
try {
    $config = file_get_contents(
        '/etc/app/config.json',
        context: $context,
    );
} catch (StreamException $e) {
    foreach ($e->getErrors() as $error) {
        // $error->code is a StreamErrorCode enum case
        log_error(
            $error->code->name,
            $error->message,
            $error->wrapperName,
        );
    }
}


Nouvelle fonction clamp():

Garantit qu'une valeur donnée (numérique ou non) reste comprise dans un intervalle spécifié. Dans le cas contraire, la borne la plus proche est retournée.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var_dump(clamp(-10, 0, 100));
// int(0)
 
var_dump(clamp(50, 0, 100));
// int(50)
 
var_dump(clamp(110, 0, 100));
// int(100)
 
// Any comparable value works with clamp(). This
// includes the new Duration class.
var_dump(clamp(
    \Time\Duration::fromSeconds(30),
    min: \Time\Duration::fromMinutes(1),
    max: \Time\Duration::fromMinutes(10),
)->seconds);
// int(60)
Nouvelle énumération SortDirection:

L'énumération SortDirection offre, avec ses cas Ascending et Descending, une manière partagée et typée d'exprimer un ordre de tri. Auparavant, chaque bibliothèque devait définir sa propre représentation de la direction de tri, ce qui aboutissait à un mélange d'entiers, de chaînes, de booléens et d'énumérations personnalisées incompatibles. Comme [/]SortDirection[/c] est intégrée à PHP, les bibliothèques peuvent l'accepter dans leurs API publiques sans code d'adaptation.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class QueryBuilder
{
    private array $orderBy = [];
 
    public function orderBy(
        string $column,
        SortDirection $direction = SortDirection::Ascending,
    ): static {
        $this->orderBy[] = $column . ' ' . match ($direction) {
            SortDirection::Ascending => 'ASC',
            SortDirection::Descending => 'DESC',
        };
 
        return $this;
    }
}
 
$qb->orderBy('name', SortDirection::Descending);
$qb->orderBy('name', SORT_STRING);
// TypeError: QueryBuilder::orderBy(): Argument #2 ($direction)
// must be of type SortDirection, int given


DocComments pour les paramètres de fonction

Les paramètres de fonctions et de méthodes peuvent désormais avoir leurs propres DocComments, accessibles via la nouvelle méthode ReflectionParameter::getDocComment(). Chaque paramètre peut ainsi être documenté juste à côté de sa déclaration, sans répéter son nom et son type dans une balise @param.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class QueryBuilder
{
    private array $orderBy = [];
 
    public function orderBy(
        string $column,
        SortDirection $direction = SortDirection::Ascending,
    ): static {
        $this->orderBy[] = $column . ' ' . match ($direction) {
            SortDirection::Ascending => 'ASC',
            SortDirection::Descending => 'DESC',
        };
 
        return $this;
    }
}
 
$qb->orderBy('name', SortDirection::Descending);
$qb->orderBy('name', SORT_STRING);
// TypeError: QueryBuilder::orderBy(): Argument #2 ($direction)
// must be of type SortDirection, int given
Nouvelles méthodes ReflectionProperty::isReadable() et ReflectionProperty::isWritable():

Avec les propriétés readonly, la visibilité asymétrique et les hooks de propriété, vérifier qu'une propriété est publique ne suffit plus pour savoir si elle peut être lue ou écrite. Les nouvelles méthodes répondent directement à cette question pour une portée donnée, et éventuellement pour un objet précis, en tenant compte de la visibilité, de l'état d'initialisation, des hooks et des méthodes magiques.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class NewsEntry
{
    public string $title = 'PHP 8.6 released!';
 
    public private(set) string $slug = 'php-86-released';
}
 
$entry = new NewsEntry();
foreach (['title', 'slug'] as $item) {
    $property = new ReflectionProperty(NewsEntry::class, $item);
    printf(
        "%s: isReadable=%s isWritable=%s\n",
        $item,
        $property->isReadable(null, $entry) ? 'yes' : 'no',
        $property->isWritable(null, $entry) ? 'yes' : 'no',
    );
}
// title: isReadable=yes isWritable=yes
// slug: isReadable=yes isWritable=no
Valeurs par défaut des propriétés readonly

Les propriétés d'instance readonly, y compris celles des classes readonly, peuvent désormais déclarer une valeur par défaut. Cela simplifie l'implémentation de propriétés d'interface en lecture seule avec des valeurs fixes, qui nécessitaient auparavant une assignation dans le constructeur. La valeur par défaut compte comme l'initialisation de la propriété : le constructeur ne peut donc pas l'écraser.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
interface Rule
{
    public string $parser { get; }
}
 
final readonly class SlugRule implements Rule
{
    public string $parser = SlugParser::class;
}


Source : Annonce PHP 8.6

Et vous ?

Pensez-vous que cette version est crédible ou pertinente ?
Quel est votre avis sur le sujet ?

Voir aussi :

PHP 8.5 est désormais disponible avec une fonctionnalité très attendue : l'opérateur pipe, une petite fonctionnalité au potentiel énorme mais qui a pris des années à voir le jour

Un chercheur en sécurité rapporte avoir détecté une exploitation réussie de la faille PHP2Shell, alors que des millions d'hôtes PHP tardent à appliquer les correctifs et restent exposés en ligne

Le manque de personnel et de financement explique la récente secousse de sécurité dans l'écosystème PHP. Le projet ne compte qu'un seul employé à temps plein et ce n'est que la partie visible de l'iceberg
Vous avez lu gratuitement 54 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !