Caractéristiques cachées de Perl?

Question

Quelles sont les fonctionnalités de langage Perl que vous avez réellement pu utiliser pour effectuer un travail utile?

Des lignes directrices:

Essayez de limiter les réponses au noyau 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:

(Ils sont tous de réponse de Corion )

C
- Le dispositif de Duff
- Portabilité et Normalité
C #
- Devis pour des listes et des chaînes délimitées par des espaces
- Espaces de noms aliasables
Java
- Initalisateurs statiques
JavaScript
- Les fonctions sont des citoyens de première classe
- Bloquer la portée et la fermeture
- Appeler des méthodes et des accesseurs indirectement via une variable
Ruby
- Définir des méthodes par le code
PHP
- Documentation en ligne omniprésente
- Méthodes magiques
- Références symboliques
Python
- Permutation d'une valeur de ligne
- Possibilité de remplacer même les fonctions essentielles par vos propres fonctionnalités

Autres caractéristiques cachées:

Les opérateurs:

Citant des constructions:

Syntaxe et noms:

Modules, Pragmas et options de ligne de commande:

Variables:

Boucles et contrôle de flux:

Expressions régulières:

Autres caractéristiques:

Autres astuces et méta-réponses:

Voir aussi:

John Siracusa · Answer

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

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

Courir perldoc perlop et recherchez "flip-flop" pour plus d'informations et d'exemples.

moritz · Answer

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

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

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

Ou que vous puissiez donner des noms sous-numériques 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 retourne 1 pour les expressions vraies et la chaîne vide pour false:

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

Autres choses intéressantes: avec use overload vous pouvez surcharger les littéraux de chaîne et les nombres (et par exemple les transformer en BigInts ou autre).

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

Mise à jour: Un autre Nice. Sous le q{...} citant des constructions 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/

timkay · Answer

Ajout du support pour les fichiers compressés via magic ARGV:

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;

(citations autour de $ _ nécessaire pour gérer les noms de fichiers contenant des métacaractères Shell)

Maintenant le <> fonction va décompresser n'importe quel @ARGV fichiers qui se terminent par ".gz" ou ".Z":

while (<>) { print; }

pjf · Answer

Une de mes fonctionnalités préférées dans Perl utilise le booléen || _ opérateur 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;

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

Dans Perl 5.10, il y a aussi le // opérateur, qui retourne le côté gauche s'il est défini et le côté droit sinon. Ce qui suit sélectionne la première définie valeur de $a, $b, $c, ou 0 autrement:

 $ 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, sa valeur est maintenant 0. $ X // = 0; # Si $ x n'était pas défini, sa valeur est maintenant égale à zéro.

Cheerio,

Paul

Leon Timmermans · Answer

Les opérateurs ++ et unary - ne travaillent pas seulement sur des nombres, mais aussi sur des chaînes.

my $_ = "a" print -$_

impressions - a

print ++$_

empreintes b

$_ = 'z' print ++$_

empreintes aa

Corion · Answer

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

~~Ce que Perl ne peut pas faire, c’est d’avoir des URL nues et arbitraires dans votre code, car l’opérateur // Est utilisé pour les expressions régulières.~~

Au cas où vous n'auriez pas compris ce que propose Perl, voici une liste sélective des entrées peut-être pas tout à fait évidentes:

périphérique de Duff - en Perl

Portability and Standardness - Il y a probablement plus d'ordinateurs avec Perl qu'avec un compilateur C

ne classe de manipulation de fichier/chemin - File :: Find fonctionne sur encore plus de systèmes d'exploitation que .Net

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

Espaces de noms Aliasable - Perl possède les attributs suivants:

*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 l'analyse de code) à import (lors de 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 - comme en Perl

Portée et fermeture du bloc - Perl a les deux

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

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

Définition de 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 également sur votre système

méthodes magiques qui sont appelés chaque fois que vous appelez une fonction "non existante" - Perl l'implémente dans la fonction AUTOLOAD

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

Permutation d'une valeur de ligne - Perl permet l'affectation de liste

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

J.J. · Answer

Autovivification . Autant que je sache , aucune autre langue ne l’a .

Robert P · Answer

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 citation en Perl sont très intéressants. Les mécanismes de citation de type Perl regex vous permettent de tout citer, en spécifiant les délimiteurs. Vous pouvez utiliser presque tous les caractères spéciaux tels que #, /, ou les caractères d'ouverture/fermeture tels que (), [] 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 cotation:

q: citation littérale; seul le caractère à échapper 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 comme une commande système, de manière non interactive. Renvoie tout le texte généré à partir de la sortie standard. (La redirection, si elle est prise en charge par le système d'exploitation, est également disponible). Fait également avec des guillemets arrières (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 la regex. Vous pouvez maintenant passer la regex 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 cité de mots séparés par des espaces dans une liste. Idéal pour saisir 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 clarifie les choses. 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 vous voyez parfois aussi qw //.

timkay · Answer

L'instruction "for" peut être utilisée de la même manière "avec" 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 situé au-dessus (& nbsp;) contient Unicode caché pour contourner le Markdown. Ne pas copier le coller :)

mpeters · Answer

Pas vraiment caché, mais beaucoup de programmeurs Perl ne connaissent pas tous les jours CPAN . Cela s'applique particulièrement aux personnes qui ne sont pas des programmeurs à temps plein ou qui ne programment pas à temps plein dans Perl.

dland · Answer

L'opérateur de mot-clé 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 facile à regarder. Une autre chose vraiment intéressante à propos de Perl, que l’on manque vraiment lors de l’écriture de code SQL, c’est qu’une virgule finale est légale:

print 1, 2, 3, ;

Cela semble étrange, mais pas si vous indenter 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 les virgules des lignes précédentes ou suivantes. Le changement de ligne unique n'a aucun impact sur les lignes environnantes.

Cela rend très agréable de travailler avec des fonctions variadiques. C’est peut-être l’une des caractéristiques les plus sous-estimées de Perl.

allan · Answer

La possibilité d’analyser les données directement collées dans un bloc DATA . Pas besoin de sauvegarder dans un fichier de test pour être ouvert 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

Bruno De Fraine · Answer

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

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

Cela fonctionne aussi avec les listes:

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

Axeman · Answer

Nouveau bloc d'opérations

Je dirais que la possibilité d'étendre le langage, la création d'opérations de pseudo-bloc en est un.

Vous déclarez le prototype pour un sous 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 ); } }

Vous pouvez ensuite l'appeler dans le corps comme si

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::Dumper est un autre joyau semi-caché. Notez que vous n'avez pas besoin du mot-clé sub devant le bloc, ni de la virgule avant le hachage. Cela finit par ressembler beaucoup à: map { } @list

Filtres source

En outre, il existe des filtres de source. Où Perl vous transmettra le code afin que vous puissiez le manipuler. Ceci, tout comme les opérations de bloc, sont pratiquement du genre à ne pas essayer-à-domicile.

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, permettant ainsi des lignes unidirectionnelles Perl courtes pour une prise de décision:

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

Lib::TL va simplement rechercher les "variables" et les constantes, les créer et les remplacer si nécessaire.

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

Crochets de signal

C'est souvent assez fait, mais ce n'est pas si évident. Voici un manieur de matrices qui reprend ses droits 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 (sauf si quelqu'un d'autre effectue un écrasement destructeur sur $SIG{__DIE__}). Et vous pouvez être averti que quelqu'un fait quelque chose est une erreur.

Bien sûr, pour assez 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 import sous:

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 paquets appelants sera changé en un Math::BigInt objet. (Voir surcharge :: constante ).

Littéraux entiers groupés

Tant que nous y sommes. Perl vous permet de diviser de grands nombres en groupes de trois chiffres tout en en extrayant un entier analysable. Remarque 2_000_000_000 ci-dessus pour 2 milliards.

Andru Luvisi · Answer

Vérification de la souillure. Si la vérification de la souillure est activée, Perl mourra (ou préviendra avec -t) si vous essayez de transmettre des données altérées (en gros, des données extérieures au programme) à une fonction non sécurisée (ouvrir un fichier, exécuter une commande externe, etc.). Cela est très utile lors de l'écriture de scripts setuid ou CGI ou de toute autre tâche dans laquelle le script dispose de privilèges supérieurs à ceux de la personne qui lui fournit les données.

Magie goto. goto &sub fait un appel final optimisé.

Le débogueur.

use strict et use warnings. Ceux-ci peuvent vous sauver d'un tas de fautes de frappe.

Magie goto. goto &sub fait un appel final optimisé.

Le débogueur.

use strict et use warnings. Ceux-ci peuvent vous sauver d'un tas de fautes de frappe.

Sec · Answer

Basé sur la façon dont le "-n" et "-p" Les commutateurs 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"; }

brunorc · Answer

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

Sec · Answer

Commençons facilement avec le 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

pjf · Answer

Ceci est une méta-réponse, mais les archives Perl Tips contiennent toutes sortes d’astuces intéressantes pouvant être réalisées avec Perl. Les archives des conseils précédents sont en ligne pour la navigation et peuvent être abonnées via la liste de diffusion ou atom).

Certains de mes conseils préférés incluent construction d’exécutables avec PAR , tiliser autodie pour lancer des exceptions automatiquement , et utiliser les switch et smart-match construit dans Perl 5.10.

Divulgation: Je suis l'un des auteurs et responsables de Perl Tips, je les considère donc très bien. ;)

Shawn H Corey · Answer

La clause continue sur les boucles. Il sera exécuté au bas de chaque boucle, même celles qui suivent.

while( <> ){ print "top of loop
"; chomp; next if /next/i; last if /last/i; print "bottom of loop
"; }continue{ print "continue
"; }

Leon Timmermans · Answer

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.

J.J. · Answer

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

le\G ancre. C'est chaud.

Michael Carman · Answer

Le m// l'opérateur a des cas spéciaux obscurs:

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

spoulson · Answer

Le filehandle null opérateur de diamant <> a sa place dans la construction d’outils de ligne de commande. Il agit comme <FH> à lire depuis un handle, sauf qu'il sélectionne comme par magie le premier trouvé: les noms de fichiers en ligne de commande ou STDIN. Tiré de perlop:

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

Bruno De Fraine · Answer

Blocs de code spéciaux tels que BEGIN, CHECK et END. Ils viennent d'Awk, mais fonctionnent différemment en Perl, car ils ne sont pas basés sur l'enregistrement.

Le bloc BEGIN 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 syntaxe et variable Perl -c. Par exemple, pour charger des variables de configuration:

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

timkay · Answer

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

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

Sec · Answer

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

print ~~ localtime;

est le même que

print scalar localtime;

et différent de

print localtime;

Schwern · Answer

Le "mode de désespoir" des constructions de contrôle de boucle de Perl qui les oblige à rechercher dans la pile une étiquette correspondante permet certains comportements étranges dont Test :: More tire parti, 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 peu connu .pmc. "use Foo" recherchera Foo.pmc dans @INC avant Foo.pm. Ceci était destiné à permettre le chargement du code temporel compilé en premier, mais Module :: Compile en tire parti 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 capacité de transformer les avertissements en erreurs.

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

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

Chas. Owens · Answer

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 parce que l'affectation de liste dans un contexte scalaire donne le nombre d'éléments de la liste en cours d'affectation.

* Note, pas vraiment un opérateur

shmem · Answer

Le séparateur d'enregistrement en entrée peut être défini sur une référence à un nombre afin de lire des enregistrements de longueur fixe:

$/ = \3; print $_,"
" while <>; # output three chars on each line

davidnicol · Answer

tie, l'interface attachante variable.

Schwern · Answer

Celui-ci n'est pas particulièrement utile, mais il est extrêmement ésotérique. Je suis tombé sur cela en fouillant dans l'analyseur Perl.

Avant l’utilisation du POD, Perl4 disposait d’une astuce pour vous permettre d’incorporer la page de manuel, en tant que nroff, directement dans votre programme afin de ne pas la perdre. Perl4 a utilisé un programme appelé wrapman (voir Pink Chamel page 319 pour plus de détails) pour intégrer intelligemment une page de manuel nroff à votre script.

Cela a fonctionné en disant à nroff d'ignorer tout le code, puis de mettre la viande de la page de manuel après un [~ # ~] end [~ # ~] qui indique à Perl d’arrêter le traitement du code. Ressemblait à quelque chose comme ça:

#!/usr/bin/Perl 'di'; 'ig00'; ...Perl code goes here, ignored by nroff... .00; # finish .ig 'di \" finish the diversion .nr nl 0-1 \" fake up transition to first page .nr % 0 \" start at page 1 '; __END__ ...man page goes here, ignored by Perl...

Les détails de la magie roff m'échappent, mais vous remarquerez que les commandes roff sont des chaînes ou des nombres dans un contexte vide. Normalement, une constante dans un contexte vide produit un avertissement. Il existe des exceptions spéciales dans op.c pour autoriser les chaînes de contexte vides commençant par certaines commandes roff.

 /* Perl4's way of mixing documentation and code (before the invention of POD) was based on a trick to mix nroff and Perl code. The trick was built upon these three nroff macros being used in void context. The pink camel has the details in the script wrapman near page 319. */ const char * const maybe_macro = SvPVX_const(sv); if (strnEQ(maybe_macro, "di", 2) || strnEQ(maybe_macro, "ds", 2) || strnEQ(maybe_macro, "ig", 2)) useless = NULL;

Cela signifie que 'di'; ne produit pas d’avertissement, mais 'die'; 'did you get that thing I sentcha?'; ou 'ignore this line';.

De plus, il existe des exceptions pour les constantes numériques 0 et 1 qui permet au nu .00;. Le code prétend que c'était à des fins plus générales.

 /* the constants 0 and 1 are permitted as they are conventionally used as dummies in constructs like 1 while some_condition_with_side_effects; */ else if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0)) useless = NULL;

Et que savez-vous, 2 while condition prévient!

user105090 · Answer

Vous pouvez utiliser @ {[...]} pour obtenir un résultat interpolé d'expressions Perl complexes

$a = 3; $b = 4; print "$a * $b = @{[$a * $b]}";

impressions: 3 * 4 = 12

Vince Veselosky · Answer

Je ne sais pas à quel point c'est ésotérique, mais l'un de mes favoris est le tranche de hachage . Je l'utilise pour toutes sortes de choses. Par exemple, pour fusionner deux hachages:

 mon% number_for = (un => 1, deux => 2, trois => 3); mon% your_numbers = (deux => 2, quatre => 4, six => 6 ); @ number_for {keys% your_numbers} = valeurs% your_numbers; afficher les valeurs de tri% number_for; # 12346

Robert P · Answer

use diagnostics;

Si vous commencez à travailler avec Perl et que vous ne l’avez jamais fait auparavant, ce module vous fera gagner beaucoup de temps et d’ennui. Pour presque tous les messages d'erreur de base que vous pouvez obtenir, ce module vous expliquera longuement les raisons de la rupture de votre code, ainsi que des astuces utiles pour le corriger. Par exemple:

use strict; use diagnostics; $var = "foo";

vous donne ce message utile:

 Le symbole global "$ var" requiert un nom de package explicite à la ligne 4. Exécution de - annulation en raison d'une erreur de compilation (# 1) (F) Vous avez dit " use strict vars ", ce qui indique que toutes les variables doivent être soit de portée lexicale (avec" my "), déclarées au préalable avec " notre ", soit explicitement qualifiées pour dire quel package la variable globale est entré (avec "::"). Exception non capturée du code utilisateur: Le symbole global "$ var" requiert un nom de package explicite à la ligne 4. Exécution de - annulation en raison d'une erreur de compilation. À la ligne 5

use diagnostics; use strict; sub myname { print { " Some Error " }; };

vous obtenez ce gros morceau de texte utile:

 erreur de syntaxe à la ligne 5, près de "};" Exécution de - annulé en raison d'erreurs de compilation (# 1) (F) Signifie probablement que vous avez eu une erreur de syntaxe. Les raisons courantes incluent: Un mot clé est mal orthographié. Un point-virgule est manquant. Une virgule est manquante. Une parenthèse ouvrante ou fermante est manquant. Il manque une accolade ouvrante ou fermante. Il manque un guillemet fermant. Un autre message d'erreur apparaît souvent associé à la syntaxe erreur donnant plus d'informations. (Parfois, il est utile d'activer -w.) Le message d'erreur lui-même vous indique souvent où il se trouvait dans la ligne lorsque A décidé d'abandonner. Parfois, l'erreur réelle est plusieurs jetons Avant cela, car Perl sait bien entrer une entrée aléatoire. Parfois, le numéro de ligne peut être trompeur, et une fois dans une lune bleue Le seul. Pour savoir ce qui a provoqué l'erreur, vous devez appeler Perl -c à plusieurs reprises, en coupant la moitié du programme à chaque fois pour voir [.____] si l'erreur disparaît. Tri de la version cybernétique de S. Exception non capturée du code utilisateur: Erreur de syntaxe à la ligne 5, près de "};" Exécution de - annulation à cause d’erreurs de compilation. à - ligne 7

À partir de là, vous pouvez en déduire ce qui pourrait ne pas être correct avec votre programme (dans ce cas, le format d'impression est totalement incorrect). Il y a un grand nombre d'erreurs connues avec les diagnostics. Maintenant, bien que cela ne soit pas une bonne chose à utiliser en production, cela peut constituer un outil d’apprentissage précieux pour les débutants en Perl.

timkay · Answer

sub load_file { local(@ARGV, $/) = shift; <>; }

et une version qui retourne un tableau selon le cas:

sub load_file { local @ARGV = shift; local $/ = wantarray? $/: undef; <>; }

Daniel · Answer

($ x, $ y) = ($ y, $ x) est ce qui m'a donné envie d'apprendre Perl.

La liste constructeur 1..99 ou 'a' .. 'zz' est également très agréable.

wolverian · Answer

@Schwern a mentionné la transformation des avertissements en erreurs en localisant $SIG{__WARN__}. Vous pouvez aussi le faire (lexicalement) avec use warnings FATAL => "all";. Voir perldoc lexwarn.

Sur cette note, depuis Perl 5.12, vous avez pu dire perldoc foo au lieu du complet perldoc perlfoo. Finalement! :)

Sec · Answer

Il y a aussi $ [la variable qui décide à quel index un tableau commence. La valeur par défaut est 0, donc un tableau commence à 0. En définissant

$[=1;

Vous pouvez faire en sorte que Perl se comporte davantage comme AWK (ou Fortran) si vous le souhaitez vraiment.

Jeteve · Answer

Utilisez lvalues pour rendre votre code vraiment déroutant:

my $foo = undef ; sub bar:lvalue{ return $foo ;} # Then later bar = 5 ; print bar ;

Eric Strom · Answer

Un opérateur composite utile pour l'ajout conditionnel de chaînes ou de listes dans d'autres listes est le x!!opérateur:

 print 'the meaning of ', join ' ' => 'life,' x!! $self->alive, 'the universe,' x!! ($location ~~ Universe), ('and', 'everything.') x!! 42; # this is added as a list

cet opérateur permet une syntaxe inversée similaire à

 do_something() if test();

J.J. · Answer

D'accord. Voici un autre. Portée dynamique . On en a parlé un peu dans un autre post, mais je ne l'ai pas vu ici sur les fonctionnalités cachées.

La portée dynamique telle que l'autovivification a un nombre très limité de langues qui l'utilisent. Perl et Common LISP sont les deux seuls que je connaisse qui utilisent le cadrage dynamique.

talexb · Answer

Que diriez-vous de la capacité d'utiliser

my @symbols = map { +{ 'key' => $_ } } @things;

pour générer un tableau de hashrefs à partir d'un tableau - le signe + situé devant le hashref désambiguise le bloc afin que l'interprète sache qu'il s'agit d'un hashref et non d'un bloc de code. Impressionnant.

(Merci à Dave Doyle de m'avoir expliqué cela lors de la dernière réunion des Perlmongers de Toronto.)

melo · Answer

Compartiments de sécurité.

Avec le module Safe, vous pouvez créer votre propre environnement de style bac à sable en utilisant uniquement Perl. Vous seriez alors en mesure de charger des scripts Perl dans le bac à sable.

Meilleures salutations,

Alexandr Ciornii · Answer

Coeur IO::Handle module. La chose la plus importante pour moi est que cela permette le nettoyage automatique des poignées de fichiers. Exemple:

use IO::Handle; $log->autoflush(1);

maasha · Answer

Ce document illustre comment utiliser glob pour générer toutes les combinaisons de mots d'un alphabet (A, T, C et G -> ADN) pour des mots d'une longueur spécifiée (4):

Perl -MData::Dumper -e '@CONV = glob( "{A,T,C,G}" x 4 ); print Dumper( \@CONV )'

Dario · Answer

Quantum::Superpositions

use Quantum::Superpositions; if ($x == any($a, $b, $c)) { ... }

dawg · Answer

use re debug
Doc d'utilisation sur le débogage

et

Perl -MO=Concise[,OPTIONS]
Doc on Concise

En plus d'être extrêmement flexible, expressif et capable de programmer dans le style de C, Pascal, Python et d'autres langages, il existe plusieurs commutateurs de commande de pragmas qui font de Perl mon langage 'goto' pour kanoodling initial sur un algorithme, une expression rationnelle ou des problèmes rapides à résoudre. Ces deux problèmes sont uniques à Perl et font partie de mes favoris.

use re debug: La plupart des variantes d'expressions régulières modernes doivent leur forme et leur fonction actuelles à Perl. Bien qu'il existe de nombreuses formes Perl de regex qui ne peuvent pas être exprimées dans d'autres langues, il n'y a pratiquement aucune forme de saveur de regex d'autres langues qui ne puisse être exprimée en Perl. De plus, Perl a un excellent débogueur de regex intégré pour montrer comment le moteur de regex interprète votre regex et le compare à la chaîne cible.

Exemple: J'essayais récemment d'écrire une routine CSV simple. (Oui, oui, je sais, j'aurais dû utiliser Text :: CSV ... ) mais les valeurs CSV n'étaient pas citées et simples.

Ma première prise a été /^(^(?:(.*?),){$i}/ pour extraire l'enregistrement i sur n enregistrements CSV. Cela fonctionne bien - sauf pour le dernier enregistrement ou n sur n. Je pouvais voir cela sans le débogueur.

Ensuite, j'ai essayé /^(?:(.*?),|$){$i}/ Cela n'a pas fonctionné et je ne pouvais pas voir immédiatement pourquoi. Je pensais dire (.*?) Suivi d'une virgule ou de la fin de vie. Ensuite, j'ai ajouté use re debug En haut d'un petit script de test. Ahh oui, la modification entre ,|$ N'était pas interprétée de cette façon; c'était interprété comme ((.*?),) | ($) - pas ce que je voulais.

n nouveau groupement était nécessaire . Je suis donc arrivé à la fonction /^(?:(.*?)(?:,|$)){$i}/. Alors que j'étais dans le débogueur de regex, j'ai été surpris du nombre de boucles nécessaires pour un match vers la fin de la chaîne. C'est le terme .*? Qui est assez ambigu et qui nécessite un retour en arrière excessif. J'ai donc essayé /^(?:(?:^|,)([^,]*)){$i}/ Cela fait deux choses: 1) réduit les retours en arrière à cause de la correspondance gloutonne de tous sauf une virgule 2) a permis à l'optimiseur de regex de n'utiliser l'altération qu'une seule fois sur le premier champ. En utilisant Benchmark, il est 35% plus rapide que la première regex. Le débogueur de regex est merveilleux et peu l'utilise.

Perl -MO=Concise[,OPTIONS]: Les frameworks B et Concise sont d'excellents outils pour voir comment Perl interprète votre chef-d'œuvre. L'utilisation de -MO=Concise Imprime le résultat de la traduction de votre code source par les interpréteurs Perl. Il existe de nombreuses options pour Concise et en B, vous pouvez écrire votre propre présentation des codes OP.

Comme dans cet article , vous pouvez utiliser Concise pour comparer différentes structures de code. Vous pouvez entrelacer vos lignes sources avec les codes OP qu'elles génèrent. Vérifiez-le.

Joe McMahon · Answer

Très tard pour la fête, mais: attributs.

Les attributs vous permettent essentiellement de définir du code arbitraire à associer à la déclaration d'une variable ou d'un sous-programme. La meilleure façon de les utiliser est avec Attribute :: Handlers ; cela facilite la définition des attributs (en termes de, quoi d'autre, attributs!).

J'ai fait une présentation sur leur utilisation pour assembler de manière déclarative une classe pluggable et ses plugins à l'adresse YAPC :: 2006, en ligne ici . C'est une caractéristique assez unique.

Chris Lutz · Answer

Personnellement, j'adore le modificateur/e de l'opération s ///:

while(<>) { s/(\w{0,4})/reverse($1);/e; # reverses all words between 0 and 4 letters print; }

Contribution:

This is a test of regular expressions ^D

Sortie (je pense):

sihT si a tset fo regular expressions

Justin · Answer

Vous pouvez utiliser différentes citations sur HEREDOCS pour obtenir des comportements différents.

my $interpolation = "We will interpolated variables"; print <<"END"; With double quotes, $interpolation, just like normal HEREDOCS. END print <<'END'; With single quotes, the variable $foo will *not* be interpolated. (You have probably seen this in other languages.) END ## this is the fun and "hidden" one my $Shell_output = <<`END`; echo With backticks, these commands will be executed in Shell. echo The output is returned. ls | wc -l END print "Shell output: $Shell_output
";

Alexey · Answer

Il existe un moyen plus puissant de vérifier les erreurs de syntaxe du programme:

Perl -w -MO=Lint,no-context myscript.pl

La chose la plus importante à faire est de signaler les erreurs de "sous-programme non-inexistant".

Telemachus · Answer

Ma fonctionnalité semi-cachée préférée de Perl est la fonction eof. Voici un exemple directement tiré de perldoc -f eof qui montre comment vous pouvez l’utiliser pour réinitialiser le nom du fichier et $. (le numéro de ligne actuel) facilement sur plusieurs fichiers chargés en ligne de commande:

while (<>) { print "$ARGV:$.	$_"; } continue { close ARGV if eof }

Guillaume Gervais · Answer

Vous pouvez remplacer le délimiteur dans les expressions rationnelles et les chaînes par n'importe quoi d'autre. Ceci est particulièrement utile pour le "syndrome du cure-dent penché", illustré ici:

$url =~ /http:\/\/www\.stackoverflow\.com\//;

Vous pouvez éliminer la plupart des problèmes de dos en modifiant le délimiteur. /bar/ est un raccourci pour m/bar/ qui est identique à m!bar!.

$url =~ m!http://www\.stackoverflow\.com/!;

Vous pouvez même utiliser des délimiteurs équilibrés comme {} et []. Personnellement, je les aime. q{foo} est le même que 'foo'.

$code = q{ if( this is awesome ) { print "Look ma, no escaping!"; } };

Pour dérouter vos amis (et votre surligneur de syntaxe), essayez ceci:

$string = qq'You owe me $1,000 dollars!';

J.J. · Answer

Axeman m'a rappelé combien il est facile d'envelopper certaines des fonctions intégrées.

Avant Perl 5.10, Perl n’avait pas une jolie impression (disons) comme Python.

Donc, dans votre programme local, vous pourriez faire quelque chose comme:

sub print { print @_, "
"; }

ou ajouter un peu de débogage.

sub print { exists $ENV{DEVELOPER} ? print Dumper(@_) : print @_; }

ikegami · Answer

Les éléments suivants sont tout aussi brefs, mais plus significatifs que "~~", car ils indiquent ce qui est renvoyé, et il n'y a pas de confusion avec l'opérateur de correspondance intelligente:

print "".localtime; # Request a string print 0+@array; # Request a number

Jauder Ho · Answer

La possibilité d'utiliser un hachage en tant que filtre visible dans une boucle. Je n'ai pas encore vu quelque chose d'aussi beau dans une langue différente. Par exemple, je n’ai pas pu dupliquer cela en python.

Par exemple, je veux imprimer une ligne si elle n’a pas été vue auparavant.

my %seen; for (<LINE>) { print $_ unless $seen{$_}++; }

Danny Woods · Answer

Deux choses qui fonctionnent bien ensemble: IO gère les chaînes en noyau, et l’utilisation de prototypes de fonctions pour vous permettre d’écrire vos propres fonctions avec une syntaxe semblable à celle de grep/map.

sub with_output_to_string(&) { # allows compiler to accept "yoursub {}" syntax. my $function = shift; my $string = ''; my $handle = IO::Handle->new(); open($handle, '>', \$string) || die $!; # IO handle on a plain scalar string ref my $old_handle = select $handle; eval { $function->() }; select $old_handle; die $@ if $@; return $string; } my $greeting = with_output_to_string { print "Hello, world!"; }; print $greeting, "
";

gdey · Answer

La fonctionnalité que j'aime le mieux est les modificateurs d'instructions.

Je ne sais pas combien de fois j'ai voulu faire:

say 'This will output' if 1; say 'This will not output' unless 1; say 'Will say this 3 times. The first Time: '.$_ for 1..3;

dans d'autres langues. etc...

Le "etc" m'a rappelé une autre fonctionnalité 5.12, l'opérateur Yada Yada.

C'est génial, pour les moments où vous voulez juste un remplaçant.

sub something_really_important_to_implement_later { ... }

Jetez-y un œil: Documents Perl sur l’opérateur Yada Yada .

knb · Answer

La nouvelle option -E sur la ligne de commande:

> Perl -e "say 'hello"" # does not work String found where operator expected at -e line 1, near "say 'hello'" (Do you need to predeclare say?) syntax error at -e line 1, near "say 'hello'" Execution of -e aborted due to compilation errors. > Perl -E "say 'hello'" hello

trapd00r · Answer

Vous pouvez développer les appels de fonction dans une chaîne, par exemple;

print my $foo = "foo @{[scalar(localtime)]} bar";

foo mer. 26 mai 15:50:30 2010 bar

Erick · Answer

Interpolation des expressions régulières correspondantes. Une application utile de cela est lors de la mise en correspondance sur une liste noire. Sans utiliser l'interpolation, il est écrit comme suit:

#detecting blacklist words in the current line /foo|bar|baz/;

Peut plutôt être écrit

@blacklistWords = ("foo", "bar", "baz"); $anyOfBlacklist = join "|", (@blacklistWords); /$anyOfBlacklist/;

Ceci est plus détaillé, mais permet la population à partir d’un fichier de données. De plus, si la liste est maintenue dans la source pour une raison quelconque, il est plus facile de gérer le tableau que RegExp.

Nick Dixon · Answer

Utilisation de hachages (où les clés sont uniques) pour obtenir les éléments uniques d’une liste:

my %unique = map { $_ => 1 } @list; my @unique = keys %unique;

timkay · Answer

Vous pourriez penser que vous pouvez le faire pour économiser de la mémoire:

@is_month{qw(jan feb mar apr may jun jul aug sep oct nov dec)} = undef; print "It's a month" if exists $is_month{lc $mon};

mais ça ne fait pas ça. Perl affecte toujours une valeur scalaire différente à chaque clé. Devel :: Peek montre cela. PVHV est le hachage. Elt est une clé et le SV qui suit est sa valeur. Notez que chaque SV a une adresse de mémoire différente indiquant qu'il n'est pas partagé.

Dump \%is_month, 12; SV = RV(0x81c1bc) at 0x81c1b0 REFCNT = 1 FLAGS = (TEMP,ROK) RV = 0x812480 SV = PVHV(0x80917c) at 0x812480 REFCNT = 2 FLAGS = (SHAREKEYS) ARRAY = 0x206f20 (0:8, 1:4, 2:4) hash quality = 101.2% KEYS = 12 FILL = 8 MAX = 15 RITER = -1 EITER = 0x0 Elt "feb" HASH = 0xeb0d8580 SV = NULL(0x0) at 0x804b40 REFCNT = 1 FLAGS = () Elt "may" HASH = 0xf2290c53 SV = NULL(0x0) at 0x812420 REFCNT = 1 FLAGS = ()

Un scalaire undef prend autant de mémoire qu'un scalaire entier, vous pouvez donc vous demander de simplement les attribuer à 1 et éviter le piège de l'oubli de vérifier avec exists.

my %is_month = map { $_ => 1 } qw(jan feb mar apr may jun jul aug sep oct nov dec); print "It's a month" if $is_month{lc $mon});

Mark Maunder · Answer

La prochaine fois que vous participerez à une fête geek, sortez ce one-line dans une coquille et les femmes vous envahiront et vos amis vous adoreront:

trouver . -name "* .txt" | xargs Perl -pi -e 's/1: (\ S +)/uc ($ 1)/ge'

Traitez tous les fichiers * .txt et effectuez une recherche et un remplacement sur place à l’aide des expressions rationnelles de Perl. Celui-ci convertit le texte après un '1:' en majuscule et supprime le '1:'. Utilise le modificateur 'e' de Perl pour traiter la deuxième partie de la regex find/replace en tant que code exécutable. Système de gabarit instantané à une ligne. L'utilisation de xargs vous permet de traiter un grand nombre de fichiers sans respecter la limite de longueur de ligne de commande de bash.

Kiffin · Answer

L'expression defined &DB::DB renvoie true si le programme est exécuté à partir du débogueur.

Peter · Answer

Ajoutez-en une pour les fonctions unpack () et pack (), ce qui est très bien si vous devez importer et/ou exporter des données dans un format utilisé par d'autres programmes.

Bien entendu, ces jours-ci, la plupart des programmes vous permettront d'exporter des données au format XML, et de nombreux formats de document propriétaires couramment utilisés sont associés à des modules Perl. Mais c’est une de ces fonctionnalités qui est incroyablement utile lorsque vous en avez besoin, et pack ()/unpack () sont probablement les raison qui ont permis d’écrire des modules CPAN pour autant de formats de données propriétaires .

AmbroseChapel · Answer

Je suis un peu en retard pour le parti, mais un vote pour la fonction de hachage liée intégrée dbmopen() - cela m'a beaucoup aidé. Ce n'est pas exactement une base de données, mais si vous devez enregistrer des données sur un disque, cela élimine de nombreux problèmes et Just Works. Cela m'a aidé à démarrer lorsque je n'avais pas de base de données, que je ne comprenais pas Storable.pm, mais je savais que je voulais aller au-delà de la lecture et de l'écriture dans des fichiers texte.

Prakash K · Answer

B :: Deparse - Le compilateur Perl produit le code Perl. Ce n'est pas quelque chose que vous utiliseriez dans votre code Perl quotidien, mais qui pourrait être utile dans des circonstances spéciales.

Si vous rencontrez du code obscurci ou une expression complexe, transmettez-le à travers Deparse. Utile pour comprendre un code JAPH ou Perl golfé.

$ Perl -e '$"=$,;*{;qq{@{[(A..Z)[qq[0020191411140003]=~m[..]g]]}}}=*_=sub{print/::(.*)/};$\=$/;q<Just another Perl Hacker>->();' Just another Perl Hacker $ Perl -MO=Deparse -e '$"=$,;*{;qq{@{[(A..Z)[qq[0020191411140003]=~m[..]g]]}}}=*_=sub{print/::(.*)/};$\=$/;q<Just another Perl Hacker>->();' $" = $,; *{"@{[('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')['0020191411140003' =~ /../g]];}";} = *_ = sub { print /::(.*)/; } ; $\ = $/; 'Just another Perl Hacker'->(); -e syntax OK

Un exemple plus utile consiste à utiliser deparse pour trouver le code derrière un coderef, que vous avez peut-être reçu d'un autre module, ou

use B::Deparse; my $deparse = B::Deparse->new; $code = $deparse->coderef2text($coderef); print $code;

Eric Strom · Answer

en utilisant des blocs nus avec redo ou d’autres mots de contrôle pour créer des constructions en boucle personnalisées.

parcourir une liste d'objets liés en renvoyant la première méthode ->can('print'):

sub get_printer { my $self = shift; {$self->can('print') or $self = $self->next and redo} }

On Elpeleg · Answer

Un de plus...

Cache Perl:

my $processed_input = $records || process_inputs($records_file);

Sur Elpeleg Open Source, Perl CMS http://www.web-app.net/

Tomasz · Answer

Afficher les progrès dans le script en imprimant sur la même ligne:

$| = 1; # flush the buffer on the next output for $i(1..100) { print "Progress $i %\r" }

Terry · Answer

Perl est excellent comme un awk/sed flexible.

Par exemple, utilisons un simple remplacement pour ls | xargs stat, Fait naïvement comme:

$ ls | Perl -pe 'print "stat "' | sh

Cela ne fonctionne pas bien lorsque l'entrée (noms de fichiers) contient des espaces ou des caractères spéciaux du shell tels que |$\. Des guillemets simples sont donc souvent requis dans la sortie Perl.

Une complication avec l'appel de Perl via la ligne de commande -ne Réside dans le fait que le shell obtient le premier quartet sur votre ligne. Cela conduit souvent à s'échapper pour le satisfaire.

Une fonctionnalité 'cachée' que j'utilise tout le temps est \x27 pour inclure un guillemet simple au lieu d'essayer d'utiliser l'échappement Shell '\''

Alors:

$ ls | Perl -nle 'chomp; print "stat '\''$_'\''"' | sh

peut être écrit en toute sécurité:

$ ls | Perl -pe 's/(.*)/stat \x27$1\x27/' | sh

Cela ne fonctionnera pas avec des personnages amusants dans les noms de fichiers, même cités comme ça. Mais cela va:

$ ls | Perl -pe 's/
/\0/' | xargs -0 stat

Jet · Answer

"à présent"

sub _now { my ($now) = localtime() =~ /([:\d]{8})/; return $now; } print _now(), "
"; # 15:10:33

Toby · Answer

@Corion - Des URL nues en Perl? Bien sûr, vous pouvez le faire, même dans des chaînes interpolées. La seule fois où cela aurait de l'importance est dans une chaîne que vous utilisiez en tant qu'expression régulière.

mob · Answer

$ 0 est le nom du script Perl en cours d'exécution. Il peut être utilisé pour obtenir le contexte dans lequel un module est exécuté.

# MyUsefulRoutines.pl sub doSomethingUseful { my @args = @_; # ... } if ($0 =~ /MyUsefulRoutines.pl/) { # someone is running Perl MyUsefulRoutines.pl [args] from the command line &doSomethingUseful (@ARGV); } else { # someone is calling require "MyUsefulRoutines.pl" from another script 1; }

Cet idiome est utile pour traiter un script autonome avec des sous-routines utiles dans une bibliothèque pouvant être importée dans d'autres scripts. Python a une fonctionnalité similaire avec le object.__== "__main__" idiome.