URL:     https://linuxfr.org/news/perl-5-40-est-sorti
Title:   Perl 5.40 est sorti
Authors: Emmanuel Seyman
         Benoît Sibaud et Xavier Teyssier
Date:    2024-06-13T22:19:42+02:00
License: CC By-SA
Tags:    perl
Score:   3


Perl est un langage généraliste créé en 1987 par Larry Wall. Il est distribué sous une double licence : Artistic Licence et GPL v1+. La plupart des modules du CPAN, dépôt de référence pour des modules tiers, sont également sous ces deux licences. Perl est inclus dans la quasi-totalité des distributions GNU/Linux.



La toute dernière version de Perl, la 5.40.0, est sortie le 9 juin 2024. Vous la retrouverez bientôt dans votre distribution préférée.

----

[Perl sur Wikipedia](https://fr.wikipedia.org/wiki/Perl_(langage))
[Guide Perl - Débuter et progresser en Perl](https://formation-perl.fr/guide-perl.html)
[L'annonce de la sortie](https://www.nntp.perl.org/group/perl.perl5.porters/2024/06/msg268252.html)
[Le site officiel de Perl](https://www.perl.org/)

----

Améliorations notables
======================
Nouveau mot clé __CLASS__
-------------------------



Lors de l’utilisation de la nouvelle fonctionnalité classe, le code à l’intérieur d’une fonction, d’un bloc ADJUST ou d’une expression d’initialisation de field peut maintenant utiliser le nouveau mot-clé __CLASS__.



```perl
use feature 'class';

class Example1 {
    field $f = __CLASS__->default_f;

    sub default_f { 10 }
}
```




Cela donne un nom de classe, similaire à __PACKAGE__, mais alors que celui-ci donne le paquetage de compilation dans lequel le code apparaît, le mot clé __CLASS__ donne la classe d’exécution réelle dont l’instance d’objet est membre.



```perl
class Example2 :isa(Example1) {
    sub default_f { 20 }
}

my $obj = Example2->new;
# $f aura maintenant la valeur 20
```




Cela le rend utile pour l’aiguillage des fonctions sur cette classe, en particulier lors des constructeurs, où l’accès à $self n’est pas autorisé.



un attribut :reader pour les variables field



Lors de l’utilisation de la fonctionnalité de classe, les variables de champ peuvent désormais prendre un attribut :reader. Ceci crée automatiquement une fonction qui renvoie simplement la valeur de la variable de champ de l’instance donnée.



    field $name :reader;
est donc l’équivalent de
```
field $name;
method name () { return $name; }
```




On peut donner un nom différent à cette fonction :
    `field $name :reader(get_name);`



Autoriser un espace dans l’option de ligne de commande -M
---------------------------------------------------------



Lors du traitement des options de ligne de commande, Perl autorise désormais un espace entre le commutateur -M et le nom du module qui le suit.



    $ perl -M Data::Dumper=Dumper -E 'say Dumper [1,2,3]'
Cela correspond au fonctionnement de l’option -I.



Restrictions d’utilisation des déclarations VERSION
---------------------------------------------------



Dans Perl 5.36, un avertissement de dépréciation avait été ajouté lors de la rétrogradation d’une déclaration d’utilisation VERSION d’une version supérieure à 5.11 vers une version inférieure. Ceci est désormais une erreur fatale.



De plus, c’est désormais une erreur fatale d’émettre une déclaration d’utilisation ultérieure VERSION lorsqu’une autre est dans la portée, lorsque l’une ou l’autre des versions est 5.39 ou supérieure. Un avertissement de dépréciation a également été ajouté pour toute autre déclaration d’utilisation ultérieure de VERSION inférieure à la version 5.39, pour avertir qu’elle ne sera plus autorisée dans la version Perl 5.44.



Nouvelles fonctions Builtin::inf et Builtin::nan
------------------------------------------------
Deux nouvelles fonctions, inf et nan, ont été ajoutées à l’espace de noms intégré. Celles-ci agissent comme des constantes qui donnent respectivement la valeur infinie à virgule flottante et Not-a-Number.



Nouveau opérateur ^^ xor logique
--------------------------------
Perl a toujours eu trois opérateurs logiques de faible priorité and, or et xor, ainsi que trois équivalents de priorité élevée &, ^ et | traitant les opérandes bit par bit. Jusqu’à cette version, alors que les opérateurs logiques de priorité moyenne && et || étaient présents, il n’y avait pas d’équivalent xor. Cette version de Perl ajoute l’opérateur ^^, complétant l’ensemble.
    `$x ^^ $y and say "L’un de x et y est vrai, mais pas les deux";`



Le pragma features de 5.40 contient try / catch
-----------------------------------------------
Le mot-clé _features_ active maintenant la fonctionnalité try / catch, récemment stabilisée. Comme cet ensemble de fonctionnalités est activé par l’option de ligne de commande -E, ceux-ci sont immédiatement disponibles dans les scripts lancés avec cette option.


Securité
========
CVE-2023-47038
--------------



Cette vulnérabilité a été remontée à l’équipe sécurité de Perl par Nathan Mills.



Une expression régulière compilée par perl 5.30.0 jusqu’à 5.38.0 peut provoquer un buffer overflow d’un octet contrôlé par l’attaquant.



CVE-2023-47039
--------------



Cette vulnérabilité a été remontée au Intel Product Security Incident Response Team (PSIRT) par l’utilisateur GitHub [ycdxsb](https://github.com/ycdxsb/WindowsPrivilegeEscalation). Le PSIRT l’a ensuite remonté à l’équipe sécurité de Perl. À noter qu’elle ne concerne que Perl pour Windows.



Perl pour Windows dépend sur la variable d’environnement PATH pour trouver le shell (cmd.exe). Lorsqu’on lance un exécutable qui utilise l’interpréteur Perl, Perl essaie d’abord de trouver et utiliser cmd.exe dans le répertoire courant. Il est possible d’exploiter ce comportement pour faire exécuter du code malicieux à l’administrateur du poste.



Changements incompatibles avec les versions précédentes
=======================================================



reset EXPR appelle maitenant "set-magic" sur les scalaires
----------------------------------------------------------



Précédemment, reset EXPR n’appelait pas les fonctions « magiques » lorsqu’il effaçait des variables scalaires. Cela signifiait que les changements n’étaient pas répercutés sur l’état interne des variables magiques lorsque c’était nécessaire, comme c’est le cas pour $^W, et cela ne déclenchait pas d’exception lorsque la magie sous-jacente aurait dû déclencher une exception, comme pour $1.



Cela signifie que du code qui était jusqu’à présent sans effet peut, maintenant, avoir un effet, ou même déclencher une exception.



Il n’y a aucun effet pour un reset ordinaire dont le but est de réinitialiser les recherches simples appelées par m?regexp?



Avertissement lors de l’appel de la méthode import sur un paquetage inconnu
---------------------------------------------------------------------------



Historiquement, il était possible d’appeler la méthode import ou unimport pour n’importe quelle classe, y compris les classes qui n’ont pas été définies. Même si l’appel se faisait avec un argument, cela ne déclenchait pas d’erreur. Par exemple, le code suivant ne déclenche pas d’erreur en Perl 5.38:



  Classe::qui::n::existe::pas->import("toto");



Toutefois, à partir de Perl 5.39.1, cette pratique est dépréciée et déclenche un avertissement. On peut remarquer que l’appel de ces méthodes sans argument continue à s’exécuter sans déclencher d’erreur. Par exemple



  Classe::qui::n::existe::pas->import();



continue à ne pas déclencher d’erreur. C’est parce que toutes les classes dérivent implicitement de la classe UNIVERSAL, qui définit maintenant une méthode import. Dans les anciens Perl, cette méthode n’était pas définie pour UNIVERSAL. Au lieu de cela, les appels à import et à unimport étaient traités de façon spéciale de manière à ce qu’ils ne déclenchent pas d’erreur si la méthode correspondante n’était pas définie.


Ce changement a été mis en place pour faciliter la détection des fautes de frappe dans les instructions use, lorsque le programme tourne sur un système de fichiers avec des noms insensibles à la casse. Par exemple, sur Windows ou sur toute plateforme avec dse noms de fichier insensibles à la casse, avec un ancien Perl, le code suivant



  use STRICT 'refs';



serait passé sans déclencher d’erreur et sans rien faire, car le module s’appelle réellement strict.pm au lieu de STRICT.pm, donc il aurait été chargé, mais sa fonction import n’aurait jamais été appelée. Cette nouveauté permet également de détecter le cas où un utilisateur ajoute un argument à la commande use pour un paquetage qui ne définit pas son propre import. C’est le cas entre autres pour la définition d’une classe « pure », qui ne définit pas de méthode « import ».



return ne permet plus de renvoyer un objet indirect
---------------------------------------------------



La syntaxe de l’opérateur return rejette maintenant les objets indirects. Jusqu’à présent, dans la plupart des cas, cela passait à la compilation et cela pouvait même s’exécuter, mais ce n’était pas documenté et cela pouvait produire des résultats prêtant à confusion. Par exemple :



```perl
  # Remarquez que « somme » n’a pas été défini
  sub somme_positive {
    return somme grep $_ > 0, @_;
    # interprété abusivement ainsi :
    #   return *somme, grep $_ > 0, @_;
    # avec le mot somme pris en tant que typeglob et transmis en tant qu’argument supplémentaire
  }
  say for somme_positive(-1, 2 ,3);
```




produisait



```perl
  *main::somme
  2
  3
```





Dans les appels de méthode, les noms de classe sans guillemets ne sont plus interprétés comme des handles de fichier si l’on a déclaré `no feature "bareword_filehandles"`



Si l’on déclare `no feature "bareword_filehandles"`, les handles de fichier sans guillemets continuent à être acceptés dans les appels de méthode :



```perl
  open FH, "<", $somefile or die;
  no feature 'bareword_filehandles';
  FH->binmode;
```





Cela a été corrigé, donc maintenant la ligne



`FH->binmode;`



essaiera de résoudre FH en tant que classe, ce qui provoque habituellement une erreur à l’exécution.



Les handles de fichier standard tels que STDOUT continuent à être résolus en tant que handles :



```perl
no feature 'bareword_filehandles';
STDOUT->flush; # continues to work
```





Notez qu’une fois que Perl a résolu un nom sans guillemets en tant que classe, il continuera à le faire :



```perl
package SomeClass {
    sub somemethod{}
}
open SomeClass, "<", "somefile" or die;
# SomeClass résolu en tant que handle
SomeClass->binmode;
{
    no feature "bareword_filehandles";
    SomeClass->somemethod;
}
# SomeClass résolu en tant que classe
SomeClass->binmode;
```