Fonctionnalités cachées de Perl?

Quelles sont les fonctionnalités de langage vraiment utiles mais ésotériques de Perl que vous avez pu utiliser pour faire un travail utile?

Des lignes directrices:

• Essayez de limiter les réponses au cœur Perl et non au CPAN
• Veuillez donner un exemple et une brève description

Fonctionnalités cachées également trouvées dans les fonctionnalités cachées d'autres langues:

(Tout cela vient de la réponse de Corion )

• C
  • L'appareil de Duff
  • Portabilité et standardité
• C #
  • Citations pour les listes et les chaînes délimitées par des espaces
  • Espaces de noms aliasables
• Java
  • Initaliseurs statiques
• JavaScript
  • Les fonctions sont des citoyens de première classe
  • Bloquer la portée et la fermeture
  • Appeler indirectement des méthodes et des accesseurs via une variable
• Rubis
  • Définition de méthodes via le code
• PHP
  • Documentation en ligne omniprésente
  • Méthodes magiques
  • Références symboliques
• Python
  • Échange de valeur sur une ligne
  • Possibilité de remplacer même les fonctions de base par vos propres fonctionnalités

Autres fonctionnalités cachées:

Les opérateurs:

• Le quasi-opérateur booléen
• L'opérateur de bascule
  • Également utilisé pour la construction de liste
• Les opérateurs ++et unaires -fonctionnent sur des chaînes
• L'opérateur de répétition
• L'opérateur de vaisseau spatial
• Le || opérateur (et // opérateur) pour sélectionner parmi un ensemble de choix
• L'opérateur diamant
• Cas particuliers de l' m//opérateur
• L'opérateur tilde-tilde

Citant des constructions:

• L'opérateur qw
• Les lettres peuvent être utilisées comme séparateurs de guillemets dans les constructions de type q {}
• Mécanismes de cotation

Syntaxe et noms:

• Il peut y avoir un espace après un sceau
• Vous pouvez donner des noms numériques aux sous-titres avec des références symboliques
• Virgules de fin légales
• Littéraux entiers groupés
• tranches de hachage
• Remplir les clés d'un hachage à partir d'un tableau

Modules, pragmas et options de ligne de commande:

• utiliser des avertissements stricts et utiliser
• Vérification des traces
• Utilisation ésotérique de -n et -p
• CPAN
• overload::constant
• Module IO :: Handle
• Compartiments sûrs
• Les attributs

Variables:

• Autovivification
• La $[variable
• attacher
• Scoping dynamique
• Échange de variables avec une seule instruction

Boucles et contrôle de flux:

• La magie va
• for sur une seule variable
• clause continue
• Mode de désespoir

Expressions régulières:

• L' \Gancre
• (?{}) et '(?? {}) `dans les expressions rationnelles

Autres caractéristiques:

• Le débogueur
• Blocs de code spéciaux tels que BEGIN, CHECK et END
• Le DATAbloc
• Nouvelles opérations de bloc
• Filtres sources
• Crochets de signal
• carte ( deux fois )
• Fonctions intégrées d'emballage
• La eoffonction
• La dbmopenfonction
• Transformer les avertissements en erreurs

Autres astuces et méta-réponses:

• fichiers cat, décompression de gzips si nécessaire
• Astuces Perl

Voir également:

• Fonctionnalités cachées de C
• Fonctionnalités cachées de C #
• Fonctionnalités cachées de C ++
• Fonctionnalités cachées de Java
• Fonctionnalités cachées de JavaScript
• Fonctionnalités cachées de Ruby
• Fonctionnalités cachées de PHP
• Fonctionnalités cachées de Python
• Fonctionnalités cachées de Clojure

L'opérateur flip-flop est utile pour ignorer la première itération lors de la lecture en boucle des enregistrements (généralement des lignes) renvoyés par un descripteur de fichier, sans utiliser de variable indicateur:

while(<$fh>)
{
  next if 1..1; # skip first record
  ...
}

Exécutez perldoc perlopet recherchez "flip-flop" pour plus d'informations et d'exemples.

Il existe de nombreuses fonctionnalités non évidentes dans Perl.

Par exemple, saviez-vous qu'il peut y avoir un espace après un sceau?

 $ perl -wle 'my $x = 3; print $ x'
 3

Ou que vous pouvez donner des noms numériques aux sous-titres si vous utilisez des références symboliques?

$ perl -lwe '*4 = sub { print "yes" }; 4->()' 
yes

Il y a aussi le quasi-opérateur "bool", qui renvoie 1 pour les expressions vraies et la chaîne vide pour les faux:

$ perl -wle 'print !!4'
1
$ perl -wle 'print !!"0 but true"'
1
$ perl -wle 'print !!0'
(empty line)

Autre truc intéressant: avec use overloadvous pouvez surcharger les chaînes littérales et les nombres (et par exemple les rendre BigInts ou autre).

Beaucoup de ces choses sont en fait documentées quelque part, ou découlent logiquement des fonctionnalités documentées, mais certaines ne sont néanmoins pas très connues.

Mise à jour : une autre belle. Ci-dessous, les q{...}constructions de citation ont été mentionnées, mais saviez-vous que vous pouvez utiliser des lettres comme délimiteurs?

$ perl -Mstrict  -wle 'print q bJet another perl hacker.b'
Jet another perl hacker.

De même, vous pouvez écrire des expressions régulières:

m xabcx
# same as m/abc/

Ajout de la prise en charge des fichiers compressés via ARGV magique :

s{ 
    ^            # make sure to get whole filename
    ( 
      [^'] +     # at least one non-quote
      \.         # extension dot
      (?:        # now either suffix
          gz
        | Z 
       )
    )
    \z           # through the end
}{gzcat '$1' |}xs for @ARGV;

(guillemets autour de $ _ nécessaires pour gérer les noms de fichiers avec des métacaractères shell)

Désormais, la <>fonction décompresse tous les @ARGVfichiers qui se terminent par ".gz" ou ".Z":

while (<>) {
    print;
}

L'une de mes fonctionnalités préférées en Perl est d'utiliser l' ||opérateur booléen pour choisir entre un ensemble de choix.

 $x = $a || $b;

 # $x = $a, if $a is true.
 # $x = $b, otherwise

Cela signifie que l'on peut écrire:

 $x = $a || $b || $c || 0;

de prendre la première vraie valeur de $a, $bet $c, ou un défaut 0autrement.

En Perl 5.10, il y a aussi l' //opérateur, qui renvoie le côté gauche s'il est défini, et le côté droit sinon. Les sélections suivantes de la première définie valeur de $a, $b, $c, ou 0autrement:

$ x = $ a // $ b // $ c // 0;

Ceux-ci peuvent également être utilisés avec leurs formes abrégées, qui sont très utiles pour fournir des valeurs par défaut:

$ x || = 0; # Si $ x était faux, il a maintenant une valeur de 0.

$ x // = 0; # Si $ x n'était pas défini, il a maintenant une valeur de zéro.

Cheerio,

Paul

Les opérateurs ++ et unaire - ne fonctionnent pas seulement sur les nombres, mais aussi sur les chaînes.

my $_ = "a"
print -$_

impressions -a

print ++$_

impressions b

$_ = 'z'
print ++$_

imprime aa

Comme Perl a presque toutes les parties "ésotériques" des autres listes, je vais vous dire une chose que Perl ne peut pas:

La seule chose que Perl ne peut pas faire est d'avoir des URL arbitraires nues dans votre code, car l' //opérateur est utilisé pour les expressions régulières.

Juste au cas où vous ne sauriez pas quelles sont les fonctionnalités offertes par Perl, voici une liste sélective des entrées peut-être pas totalement évidentes:

Appareil de Duff - en Perl

Portabilité et standardité - Il y a probablement plus d'ordinateurs avec Perl qu'avec un compilateur C

Une classe de manipulation de fichiers / chemins - File :: Find fonctionne sur encore plus de systèmes d'exploitation que .Net

Citations pour les listes et les chaînes délimitées par des espaces - Perl vous permet de choisir des guillemets presque arbitraires pour votre liste et les délimiteurs de chaîne

Espaces de noms aliasables - Perl les a via des affectations globales:

*My::Namespace:: = \%Your::Namespace

Initialiseurs statiques - Perl peut exécuter du code dans presque toutes les phases de compilation et d'instanciation d'objet, de BEGIN(analyse de code) à CHECK(après analyse de code) à import(à l'importation du module) à new(instanciation d'objet) à DESTROY(destruction d'objet) à END(sortie de programme)

Les fonctions sont des citoyens de première classe - tout comme en Perl

Bloquer la portée et la fermeture - Perl a les deux

Appeler indirectement des méthodes et des accesseurs via une variable - Perl le fait aussi:

my $method = 'foo';
my $obj = My::Class->new();
$obj->$method( 'baz' ); # calls $obj->foo( 'baz' )

Définir des méthodes par le code - Perl le permet aussi :

*foo = sub { print "Hello world" };

Documentation en ligne omniprésente - La documentation Perl est en ligne et probablement sur votre système aussi

Méthodes magiques qui sont appelées chaque fois que vous appelez une fonction "inexistante" - Perl l'implémente dans la fonction AUTOLOAD

Références symboliques - il est conseillé de ne pas en tenir compte. Ils mangeront vos enfants. Mais bien sûr, Perl vous permet d'offrir à vos enfants des démons assoiffés de sang.

Échange de valeurs sur une ligne - Perl permet l'affectation de listes

Possibilité de remplacer même les fonctions de base par vos propres fonctionnalités

use subs 'unlink'; 
sub unlink { print 'No.' }

ou

BEGIN{
    *CORE::GLOBAL::unlink = sub {print 'no'}
};

unlink($_) for @ARGV

Autovivification . AFAIK aucune autre langue ne l'a .

Il est simple de citer presque n'importe quel type de chaîne étrange en Perl.

my $url = q{http://my.url.com/any/arbitrary/path/in/the/url.html};

En fait, les différents mécanismes de cotation en Perl sont assez intéressants. Les mécanismes de citation de type regex Perl vous permettent de tout citer, en spécifiant les délimiteurs. Vous pouvez utiliser presque n'importe quel caractère spécial comme #, /, ou ouvrir / fermer des caractères comme (), [] ou {}. Exemples:

my $var  = q#some string where the pound is the final escape.#;
my $var2 = q{A more pleasant way of escaping.};
my $var3 = q(Others prefer parens as the quote mechanism.);

Mécanismes de devis:

q: guillemet littéral; seul le caractère qui doit être échappé est le caractère de fin. qq: une citation interprétée; traite les variables et les caractères d'échappement. Idéal pour les chaînes que vous devez citer:

my $var4 = qq{This "$mechanism" is broken.  Please inform "$user" at "$email" about it.};

qx: fonctionne comme qq, mais l'exécute ensuite en tant que commande système, de manière non interactive. Renvoie tout le texte généré à partir de la sortie standard. (La redirection, si prise en charge dans le système d'exploitation, sort également) Également faite avec des guillemets (le caractère `).

my $output  = qx{type "$path"};      # get just the output
my $moreout = qx{type "$path" 2>&1}; # get stuff on stderr too

qr: interprète comme qq, mais le compile ensuite comme une expression régulière. Fonctionne également avec les différentes options de l'expression régulière. Vous pouvez maintenant passer l'expression régulière en tant que variable:

sub MyRegexCheck {
    my ($string, $regex) = @_;
    if ($string)
    {
       return ($string =~ $regex);
    }
    return; # returns 'null' or 'empty' in every context
}

my $regex = qr{http://[\w]\.com/([\w]+/)+};
@results = MyRegexCheck(q{http://myurl.com/subpath1/subpath2/}, $regex);

qw: Un opérateur de devis très, très utile. Transforme un ensemble de mots séparés par des espaces entre guillemets en une liste. Idéal pour remplir des données dans un test unitaire.

   my @allowed = qw(A B C D E F G H I J K L M N O P Q R S T U V W X Y Z { });
   my @badwords = qw(WORD1 word2 word3 word4);
   my @numbers = qw(one two three four 5 six seven); # works with numbers too
   my @list = ('string with space', qw(eight nine), "a $var"); # works in other lists
   my $arrayref = [ qw(and it works in arrays too) ]; 

Ils sont parfaits pour les utiliser chaque fois que cela rend les choses plus claires. Pour qx, qq et q, j'utilise très probablement les opérateurs {}. L'habitude la plus courante des personnes utilisant qw est généralement l'opérateur (), mais parfois vous voyez aussi qw //.

Pas vraiment caché, mais de nombreux programmeurs Perl ne connaissent pas le CPAN . Cela s'applique particulièrement aux personnes qui ne sont pas des programmeurs à plein temps ou qui ne programment pas en Perl à plein temps.

L'instruction "for" peut être utilisée de la même manière que "with" est utilisé en Pascal:

for ($item)
{
    s/&‎nbsp;/ /g;
    s/<.*?>/ /g;
    $_ = join(" ", split(" ", $_));
}

Vous pouvez appliquer une séquence d'opérations s ///, etc. à la même variable sans avoir à répéter le nom de la variable.

REMARQUE: l'espace insécable ci-dessus (& nbsp;) a caché Unicode pour contourner le Markdown. Ne le copiez pas, collez-le :)

L'opérateur quoteword est l'une de mes choses préférées. Comparer:

my @list = ('abc', 'def', 'ghi', 'jkl');

et

my @list = qw(abc def ghi jkl);

Beaucoup moins de bruit, plus agréable pour les yeux. Une autre chose vraiment intéressante à propos de Perl, qui manque vraiment lors de l'écriture de SQL, est qu'une virgule de fin est légale:

print 1, 2, 3, ;

Cela semble étrange, mais pas si vous indentez le code d'une autre manière:

print
    results_of_foo(),
    results_of_xyzzy(),
    results_of_quux(),
    ;

L'ajout d'un argument supplémentaire à l'appel de fonction ne vous oblige pas à manipuler des virgules sur les lignes précédentes ou de fin. Le changement de ligne unique n'a aucun impact sur ses lignes environnantes.

Cela rend très agréable le travail avec des fonctions variadiques. C'est peut-être l'une des fonctionnalités les moins appréciées de Perl.

La possibilité d'analyser les données directement collées dans un bloc DATA . Pas besoin d'enregistrer dans un fichier de test à ouvrir dans le programme ou similaire. Par exemple:

my @lines = <DATA>;
for (@lines) {
    print if /bad/;
}

__DATA__
some good data
some bad data
more good data 
more good data 

Nouvelles opérations de bloc

Je dirais que la possibilité d'élargir le langage, de créer des opérations de pseudo bloc en est une.

1. Vous déclarez le prototype d'un sous-marin en indiquant qu'il prend d'abord une référence de code:

   sub do_stuff_with_a_hash (&\%) {
       my ( $block_of_code, $hash_ref ) = @_;
       while ( my ( $k, $v ) = each %$hash_ref ) { 
           $block_of_code->( $k, $v );
       }
   }

2. Vous pouvez alors l'appeler dans le corps comme ça

   use Data::Dumper;
   
   do_stuff_with_a_hash {
       local $Data::Dumper::Terse = 1;
       my ( $k, $v ) = @_;
       say qq(Hey, the key   is "$k"!);
       say sprintf qq(Hey, the value is "%v"!), Dumper( $v );
   
   } %stuff_for
   ;

( Data::Dumper::Dumperest un autre joyau semi-caché.) Remarquez que vous n'avez pas besoin du submot - clé devant le bloc ou de la virgule avant le hachage. Cela finit par ressembler beaucoup à:map { } @list

Filtres sources

Il existe également des filtres source. Où Perl vous transmettra le code pour que vous puissiez le manipuler. Cela, et les opérations de blocage, sont à peu près ce type de choses à ne pas essayer à la maison.

J'ai fait des choses intéressantes avec les filtres de source, par exemple créer un langage très simple pour vérifier l'heure, autorisant de courts one-liners Perl pour certaines prises de décision:

perl -MLib::DB -MLib::TL -e 'run_expensive_database_delete() if $hour_of_day < AM_7';

Lib::TL rechercherait simplement les "variables" et les constantes, les créerait et les remplacerait si nécessaire.

Encore une fois, les filtres sources peuvent être désordonnés, mais ils sont puissants. Mais ils peuvent gâcher les débogueurs quelque chose de terrible - et même les avertissements peuvent être imprimés avec les mauvais numéros de ligne. J'ai arrêté d'utiliser Damian's Switch car le débogueur perdrait toute capacité à me dire où j'étais vraiment. Mais j'ai trouvé que vous pouvez minimiser les dommages en modifiant de petites sections de code, en les gardant sur la même ligne.

Crochets de signal

C'est assez souvent fait, mais ce n'est pas si évident. Voici un gestionnaire de matrices qui s'appuie sur l'ancien.

my $old_die_handler = $SIG{__DIE__};
$SIG{__DIE__}       
    = sub { say q(Hey! I'm DYIN' over here!); goto &$old_die_handler; }
    ;

Cela signifie que chaque fois qu'un autre module du code veut mourir, il doit venir à vous (à moins que quelqu'un d'autre ne fasse un écrasement destructeur $SIG{__DIE__}). Et vous pouvez être averti que quelqu'un pense que quelque chose est une erreur.

Bien sûr, pour suffisamment de choses, vous pouvez simplement utiliser un END { }bloc, si tout ce que vous voulez faire est de nettoyer.

overload::constant

Vous pouvez inspecter les littéraux d'un certain type dans les packages qui incluent votre module. Par exemple, si vous utilisez ceci dans votre importsous-marin:

overload::constant 
    integer => sub { 
        my $lit = shift;
        return $lit > 2_000_000_000 ? Math::BigInt->new( $lit ) : $lit 
    };

cela signifiera que chaque entier supérieur à 2 milliards dans les packages appelants sera changé en Math::BigIntobjet. (Voir surcharge :: constante ).

Littéraux entiers groupés

Pendant que nous y sommes. Perl vous permet de diviser de grands nombres en groupes de trois chiffres et d'en tirer un entier analysable. Remarque 2_000_000_000ci-dessus pour 2 milliards.

Le binaire "x" est l' opérateur de répétition :

print '-' x 80;     # print row of dashes

Cela fonctionne également avec les listes:

print for (1, 4, 9) x 3; # print 149149149

Vérification des traces. Avec la vérification des altérations activée, perl mourra (ou avertira, avec -t) si vous essayez de transmettre des données corrompues (en gros, des données extérieures au programme) à une fonction non sécurisée (ouvrir un fichier, exécuter une commande externe, etc.). Il est très utile lors de l'écriture de scripts setuid ou de CGI ou de tout autre élément où le script a des privilèges plus importants que la personne qui alimente ses données.

La magie va. goto &subfait un appel de queue optimisé.

Le débogueur.

use strictet use warnings. Ceux-ci peuvent vous éviter de nombreuses fautes de frappe.

En fonction de la façon dont les commutateurs "-n"et "-p"sont implémentés dans Perl 5, vous pouvez écrire un programme apparemment incorrect comprenant }{:

ls |perl -lne 'print $_; }{ print "$. Files"'

qui est converti en interne en ce code:

LINE: while (defined($_ = <ARGV>)) {
    print $_; }{ print "$. Files";
}

Commençons facilement avec l' opérateur de vaisseau spatial .

$a = 5 <=> 7;  # $a is set to -1
$a = 7 <=> 5;  # $a is set to 1
$a = 6 <=> 6;  # $a is set to 0

C'est une méta-réponse, mais les archives de Perl Tips contiennent toutes sortes d'astuces intéressantes qui peuvent être réalisées avec Perl. L'archive des conseils précédents est en ligne pour la navigation et peut être abonnée via une liste de diffusion ou un flux atom.

Certains de mes conseils préférés incluent la création d'exécutables avec PAR , l' utilisation d'autodie pour lancer automatiquement des exceptions , et l'utilisation des constructions switch et smart-match dans Perl 5.10.

Divulgation: Je suis l'un des auteurs et mainteneurs de Perl Tips, donc je leur accorde évidemment une très grande importance. ;)

map - non seulement parce que cela rend le code plus expressif, mais parce que cela m'a donné envie de lire un peu plus sur cette "programmation fonctionnelle".

La clause continue sur les boucles. Elle sera exécutée au bas de chaque boucle, même celles qui sont les suivantes.

while( <> ){
  print "top of loop\n";
  chomp;

  next if /next/i;
  last if /last/i;

  print "bottom of loop\n";
}continue{
  print "continue\n";
}

Mon vote irait pour les groupes (? {}) Et (?? {}) dans les expressions régulières de Perl. Le premier exécute le code Perl, ignorant la valeur de retour, le second exécute le code, en utilisant la valeur de retour comme expression régulière.

while(/\G(\b\w*\b)/g) {
     print "$1\n";
}

l'ancre \ G. Il fait chaud .

L' m//opérateur a quelques cas spéciaux obscurs:

• Si vous utilisez ?comme délimiteur, il ne correspond qu'une seule fois, sauf si vous appelez reset.
• Si vous utilisez 'comme délimiteur, le motif n'est pas interpolé.
• Si le modèle est vide, il utilise le modèle de la dernière correspondance réussie.

L' opérateur losange de descripteur de fichier nul <>a sa place dans la création d'outils de ligne de commande. Il agit comme <FH>lire à partir d'une poignée, sauf qu'il sélectionne comme par magie celui qui est trouvé en premier: les noms de fichiers de ligne de commande ou STDIN. Tiré de perlop:

while (<>) {
...         # code for each line
}

Blocs de code spéciaux tels que BEGIN, CHECKetEND . Ils viennent d'Awk, mais fonctionnent différemment en Perl, car ils ne sont pas basés sur des enregistrements.

Le BEGINbloc peut être utilisé pour spécifier du code pour la phase d'analyse; il est également exécuté lorsque vous effectuez la vérification de la syntaxe et des variables perl -c. Par exemple, pour charger des variables de configuration:

BEGIN {
    eval {
        require 'config.local.pl';
    };
    if ($@) {
        require 'config.default.pl';
    }
}

rename("$_.part", $_) for "data.txt";

renomme data.txt.part en data.txt sans avoir à me répéter.

Un peu obscur est "l'opérateur" tilde-tilde qui force le contexte scalaire.

print ~~ localtime;

est le même que

print scalar localtime;

et différent de

print localtime;

tie, l'interface de liage variable.

Le "mode de désespoir" des constructions de contrôle de boucle de Perl qui les amène à rechercher la pile pour trouver une étiquette correspondante autorise certains comportements curieux dont Test :: More profite, pour le meilleur ou pour le pire.

SKIP: {
    skip() if $something;

    print "Never printed";
}

sub skip {
    no warnings "exiting";
    last SKIP;
}

Il y a le fichier .pmc peu connu. «use Foo» recherchera Foo.pmc dans @INC avant Foo.pm. Cela visait à permettre le chargement du bytecode compilé en premier, mais Module :: Compile en profite pour mettre en cache les modules filtrés par la source pour des temps de chargement plus rapides et un débogage plus facile.

La possibilité de transformer les avertissements en erreurs.

local $SIG{__WARN__} = sub { die @_ };
$num = "two";
$sum = 1 + $num;
print "Never reached";

C'est ce à quoi je peux penser du haut de ma tête qui n'a pas été mentionné.

L'opérateur de la chèvre *:

$_ = "foo bar";
my $count =()= /[aeiou]/g; #3

ou

sub foo {
    return @_;
}

$count =()= foo(qw/a b c d/); #4

Cela fonctionne car l'affectation de liste dans un contexte scalaire produit le nombre d'éléments de la liste en cours d'affectation.

* Remarque, pas vraiment un opérateur