condensé de perldelta (128 Ko)

seulement les changements les plus marquants

planification des versions

• une version majeure par an (Q2)

• des versions mineures tous les 2-3 mois

cycle de dépréciation court

• avertissement pendant une ou deux versions majeures

• suppression effective à la version majeure suivante

• modules retirés envoyés sur le CPAN

5.12.0 le 12 avril 2010

5.14.0 le 14 mai 2011

5.16.0 le 12 mai 2012

5.18.0 le 18 mai 2013

• 5.14 n'est plus officiellement supportée

principales nouveautés :

• refonte des hashes

• fonctions lexicales, my sub func { … }

• opérations d'ensembles de classes (?[ ])

• avertissements sur les fonctionnalités expérimentales

• nouveau mécanisme de copy-on-write

5.20.0 le 16 mai 2014

• 5.16 n'est plus officiellement supportée

principales nouveautés :

• signatures de fonctions

• déréférence postfixée

• tranche de hash

5.22.0 le 1er juin 2015

• 5.18 n'est plus officiellement supportée

5.22.1 probablement vers septembre 2015

5.22.2 probablement vers février 2016

beaucoup de petites nouveautés

beaucoup de dépréciations fatales

et bien sûr des correctifs et des optimisations

nouveaux opérateurs de bits

• use experimental "bitwise"

• & | ^ ~ traitent leurs opérandes comme des nombres (comme + == <=>)

• &. |. ^. ~. traitent leurs opérandes comme des chaînes (comme . eq cmp)

  123  |  456  => 507
 "AbC" | "aBc" => "abc"
  123  | "abC" => 123

 use experimental "bitwise";

 "AbC" |  "aBc" => 0
 "AbC" |. "aBc" => "abc"
 "あ"  |  "ßλ"  => 0
 "あ"  |. "ßλ"  => "ミλ"
  123  |  "あ"  => 123
  123  |. "あ"  => "び23"

opérateur double diamant <<>>

• comme <> mais utilisation de open à trois arguments, d'où "|cmd" qui n'est plus magique

nouvelles frontières de mot \b (UAX #29: Unicode Text Segmentation)

• \b{gcb} ou \b{g} — Grapheme Cluster Boundary, intervient entre deux \X

  • (\X étant un groupe de graphèmes, c'est-à-dire un truc qui ressemble à un simple caractère)

• \b{wb} — Word Boundary, comme \b mais plus intelligent

• \b{sb} — Sentence Boundary

nouvelles frontières de mot \b (UAX #29: Unicode Text Segmentation)

•  my $s = "Il y a plus d'une nouveauté dans Perl 5.22.0";
   say join "|", split /\b/, $s;

•  Il| |y| |a| |plus| |d|'|une| |nouveauté| |dans| |Perl| |5|.|22|.|0

•  say join "|", split /\b{wb}/, $s;

•  Il| |y| |a| |plus| |d'une| |nouveauté| |dans| |Perl| |5.22.0

option de non-capture /n

équivalent à ajouter ?: dans chaque groupe

 "hello" =~ /(hi|hello)/n;          # $1 n'est pas positionné

 "hello" =~ /(?<greet>hi|hello)/n;  # $1 et $+{greet} contiennent "hello"

 "hello" =~ /(?-n:(hi|hello))/n;    # $1 contient "hello"

use re "strict"

• (précédé d'un no warnings "experimental::re_strict")

 qr/\xABC/
 # normal : aucun message
 # strict : (F) Use \x{...} for more than two hex characters in regex

 qr/\xAG/
 # normal : (W) Illegal hexadecimal digit 'G' ignored
 # strict : (F) Non-hex character in regex

 qr/[[:ascii]]/
 # normal : aucun message, classe interprétée comme qr/[:[acis] ]/x
 # strict : (F) Unmatched ':' in POSIX class in regex

Unicode 7.0.0 + correctif sur deux caractères arabes

ajout de 2 834 caractères, dont 23 nouveaux systèmes d'écriture

• symboles monétaires : manat <₼> (Azerbaïdjan), rouble <₽> (Russie)

• 502 symboles pictographiques, dont 148 types de flèches et 238 emojis

mise à jour de l'algorithme BiDi

clarifications sur la politique de stabilité de paire de casse

ajout d'une politique de stabilité pour le type numérique

use locale accepte des arguments pour limiter son champ d'action

• :collate, :ctype, :messages, :monetary, :numeric, :time

support des suppléments POSIX.1-2008, par POSIX::localeconv()

assignation par référence

use experimental "refaliasing"

 sub foo { say "foo" }
 \&bar = \&foo;
 bar();     # affiche "foo"

 my $v = 12;
 \my $x = \$v;
 $v++;      # $v et $x valent toutes les deux 13

 \my @a = [1..3];           # @a contient (1, 2, 3)
 \my %h = { val => 123 };   # %h contient (val => 123)

 \my @b = \@a;
 push @b, 4;    # @a et @b valent (1, 2, 3, 4)

 \my (@b) = \(@a);
 push @b, 4;    # @a vaut (1, 2, 3) et @b vaut (1, 2, 3, 4)

attribut de fonction anonyme :const, expérimental

• exécute immédiatement la fonction et la remplace par sa valeur

 use experimental "const_attr";

 my $port = 1024;

 *first_port = sub :const { $port };
 sub new_port { $port++ }

 say join ", ", map new_port(), 1..5;   # 1024, 1025, 1026, 1027, 1028
 say first_port();                      # 1024

fileno fonctionne sur les descripteurs de répertoires

• (sur les systèmes qui le supportent)

le forme liste de open sur un tube fonctionne sur Win32

 open my $fh, "-|", "program", @args;

assignation à une liste répétée :

 ((undef)x2, $var) = func();

amélioration de l'analyse et de l'affichage des nombres flottants

amélioration de la gestion de NaN et Inf

support de nombres hexadécimaux flottants :

 say sprintf "%a", 4*atan2(1,1);    # 0x1.921fb54442d18p+1

"$!" (et $^E) maintenant en anglais hors de use locale

"$!" (et $^E) maintenant en UTF-8 quand approprié

signatures de fonctions déplacées avant les attributs

changements sur les prototypes *, & et \&

une tranche de liste ne renvoie une liste vide que si la liste d'origine est vide : (1..3)[3,4] renvoyait (), maintenant (undef, undef)

maintenant des erreurs fatales :

• use UNIVERSAL "..." (5.12)

• \N{} avec une séquence de plusieurs espaces

• defined(@array) et defined(%hash) (5.6.1 / 5.16)

• l'utilisation d'un hash ou tableau comme référence : %h->{foo} (5.8)

• oublier % ou @ sur un nom de hash ou tableau (5.0)

utilitaires

• a2p, s2p, find2perl

modules

• CGI, Module::Build

utilisation d'un caractère non imprimable comme nom de variable à un seul caractère

utilisation de plusieurs /x, afin de réserver /xx

utilisation d'espace insécable dans un nom personnalisé de caractère pour \N{…}

un { litéral dans une regexp (doit maintenant être protégé)

sub () { $var } si $var peut être modifiée

 sub make_constant {
     my $var = shift;
     return sub () { $var }; # ok
 }

 sub make_constant {
     my $var;
     $var = shift;
     return sub () { $var }; # déprécié
 }

analyse et mise en cache des noms de classes et méthode à la compilation

recherche dans les hashs et tableaux avec des clés constantes bien plus rapide

optimisation de ("constante")x0 et ($scalar)x0 en liste vide (mais pas (func())x0)

length plus rapide sur les chaînes non magiques et non UTF-8

dans @array = split, écriture directe dans le tableau

optimisation de join avec des valeurs constantes

fonctions plus nécessairement stockées dans des typeglobs

plates-formes à nouveau fonctionnelles

• IRIX et Tru64

• z/OS en mode EBCDIC

arrêt de support

• NeXT, AmigaOS, DJGPP, NetWare, OS/2, Plan 9