Perl

Perl

Paradigm (s)	Multi-paradigme
Paru dans	1987
Conçu par	Larry Wall
Version stable	5.10.0 (18 Décembre 2007 (2007-12-18))
Typing discipline	Dynamique
Influencé par	AWK, BASIC , BASIC-PLUS, C , C ++ , Lisp, Pascal, sed, Shell Unix
Influencé	Python , PHP, Ruby, ECMAScript, Dao, Windows PowerShell
OS	Multiplate-forme
Licence	GNU General Public License, Artistic License
http://www.perl.org/

Dans la programmation informatique, Perl est un haut niveau, d'usage général, interprété, langage de programmation dynamique. Perl a été développé par Larry Wall, linguiste travaillant comme administrateur de systèmes pour la NASA , en 1987, comme un objectif général Unix langage de script pour faire le traitement des rapports easier.Since puis, il a subi de nombreuses modifications et révisions et est devenu très populaire parmi les programmeurs. Larry Wall continue de superviser le développement de la langue de base, et de sa nouvelle version, Perl 6.

Perl emprunte caractéristiques d'autres langages de programmation dont C , scripts shell ( sh), AWK, sed et Lisp. La langue offre de puissantes installations de traitement de texte sans arbitraires limites de longueur de données, comme les nombreux outils Unix présents à l'époque, ce qui en fait la langue idéale pour manipuler des fichiers texte. Il est également utilisé pour programmation graphique, l'administration du système, programmation réseau, applications qui nécessitent un accès de base de données et programmation CGI sur le Web . Perl est surnommé comme Tronçonneuse armée suisse des langages de programmation en raison de sa flexibilité et l'adaptabilité.

Histoire

Larry Wall a commencé à travailler sur Perl en 1987, alors qu'il travaillait comme programmeur chez Unisys, et publié la version 1.0 à la comp.sources.misc newsgroup le 18 Décembre, 1987. La langue est développée rapidement au cours des prochaines années. Perl 2, sorti en 1988, a présenté une meilleure moteur d'expressions régulières. Perl 3, sorti en 1989, a ajouté le support pour flux de données binaires.

A l'origine la seule documentation pour Perl était une seule (en plus longue) page de manuel. En 1991, Programmation perl (connu pour de nombreux programmeurs Perl comme le "Camel Book") a été publié, et est devenu la référence de fait pour la langue. Dans le même temps, le numéro de version de Perl a été heurté à 4, de ne pas marquer un changement majeur dans la langue, mais d'identifier la version qui a été documenté par le livre.

Perl 4 a connu une série de versions de maintenance, aboutissant à Perl 4,036 en 1993. À ce moment, mur abandonné Perl 4 à commencer à travailler sur Perl 5.

Conception initiale de Perl 5 est poursuivie en 1994. Les perl5-porters liste de diffusion a été créée en mai 1994 pour coordonner le travail sur le portage de Perl 5 à différentes plates-formes. Il reste le principal forum pour le développement, l'entretien, et le portage de Perl 5.

Perl 5 a été libéré le 17 Octobre, 1994. Ce était une réécriture presque complète de la interprète, et a ajouté de nombreuses nouvelles fonctionnalités à la langue, y compris des objets, des références, (mes) variables lexicales, et des modules. Surtout, modules fourni un mécanisme pour étendre la langue sans modifier l'interprète. Cela a permis à l'interprète de base se stabiliser, même si elle a permis programmeurs Perl ordinaires pour ajouter de nouvelles fonctionnalités de langage.

En 2008, Perl 5 est toujours activement maintenue. Les caractéristiques importantes et de nouvelles constructions linguistiques essentielles ont été ajoutées le long du chemin, y compris Support de l'Unicode, fils, un meilleur support la programmation orientée objet et de nombreuses autres améliorations.

Le 18 Décembre 2007, le 20e anniversaire de Perl 1.0, Perl 5.10.0 a été libéré. Perl 5.10.0 inclut de nouvelles fonctionnalités notables qui la rapprochent Perl 6, parmi eux un nouveau instruction switch (appelé "donnée / quand"), mises à jour des expressions régulières, "l'opérateur match intelligent" ~~, et plus encore.

Un des événements les plus importants dans l'histoire Perl 5 a eu lieu à l'extérieur de la langue adéquate, et a été une conséquence de son soutien de module. Sur 26 octobre 1995 , le Comprehensive Perl Archive Network (CPAN) a été créé en tant que référentiel pour Perl modules et Perl lui-même. Au moment de l'écriture, il transporte plus de 13 500 modules par plus de 6500 auteurs. CPAN est largement considéré comme l'une des plus grandes forces de Perl dans la pratique.

Nom

Perl a été initialement nommé "Pearl", après la Parabole de la perle de la Evangile de Matthieu. Larry Wall a voulu donner à la langue un nom court avec des connotations positives; il prétend qu'il considérait (et rejetée) chaque mot trois et quatre lettres dans le dictionnaire. Il a également considéré le nommant après que sa femme Gloria. A découvert le mur existant PEARL langage de programmation avant la sortie officielle de Perl et a changé l'orthographe du nom.

Le nom est normalement capitalisés (Perl) en se référant à la langue et en minuscule (perl) pour désigner le programme d'interprétation soi puisque les systèmes de fichiers Unix sont sensibles à la casse. Avant la sortie de la première édition de la programmation Perl, il était courant de se référer à la langue que perl; Randal L. Schwartz, cependant, a capitalisé le nom de la langue dans le livre pour faire ressortir mieux quand composer. Le cas distinction a ensuite été adopté par la communauté.

Le nom est parfois donné comme "PERL" (pour extractions pratiques Rapport Language). Bien que l'expansion a prévalu dans de nombreux manuels d'aujourd'hui, y compris le Perl officielle page de manuel, ce est simplement une backronym. Le nom ne résiste pas officiellement pour rien, alors orthographe dans tous les bouchons est incorrect. La capitalisation adéquate est considéré comme un Shibboleth dans la communauté Perl. Plusieurs autres extensions ont été proposées, y compris le propre humour Pathologiquement Eclectic Rubbish Lister de mur. En effet, Wall affirme que le nom était destiné à inspirer de nombreuses extensions différentes.

Le symbole de chameau

Programmation Perl, publié par O'Reilly Media, dispose d'une image d'un chameau sur la couverture, et est communément appelé Le Camel Book. Cette image d'un chameau est devenu un symbole général de Perl.

Ce est également un pirate emblème, apparaissant sur certaines T-shirts et autres articles vestimentaires.

O'Reilly possède l'image en tant que marque, mais prétend utiliser leurs droits légaux seulement pour protéger «l'intégrité et l'impact de ce symbole". O'Reilly permet une utilisation non-commerciale du symbole, et fournit programmation République de logos et Perl Propulsé par touches Perl.

Vue d'ensemble

Perl est un langage de programmation généraliste initialement développé pour la manipulation de texte et maintenant utilisé pour un large éventail de tâches, y compris l'administration du système, développement web, programmation réseau, GUI développement, et plus encore.

La langue est destiné à être pratique (facile à utiliser, efficace, complet) plutôt que beau (petit, élégant, minimaliste). Ses principales caractéristiques incluent un support pour de multiples paradigmes de programmation ( de procédure, orientée objet, et modèles fonctionnels), comptage de référence gestion de la mémoire (sans garbage collector du cycle de détection), prise en charge intégrée pour le traitement de texte et une grande collection de tiers modules.

Selon Larry Wall, Perl a deux slogans. Le premier est "Il ya plus d'une façon de le faire", communément appelé TMTOWTDI et le second est "choses faciles doivent être faciles et des choses dures devraient être possibles".

Caractéristiques

La structure générale de Perl dérive largement de C. Perl est de nature procédurale, avec variables, expressions, instructions d'affectation, délimitée par des accolades les blocs de code, structures de contrôle, et des sous-programmes.

Perl prend également des fonctionnalités de la programmation du shell. Toutes les variables sont marqués avec de leader sceaux, qui identifient clairement le type de données (scalaire, un tableau, hachage, etc.) de la variable dans le contexte. Surtout, sceaux permettent de variables à interpoler directement dans les cordes. Perl a de nombreuses fonctions intégrées qui fournissent des outils souvent utilisés dans la programmation shell (bien que beaucoup de ces outils sont mis en œuvre par des programmes externes à la coque) comme le tri, et en appelant sur les installations de système.

Perl prend listes de Lisp, tableaux associatifs (hashes) de AWK, et expressions régulières, de Sed. Ces simplifier et faciliter beaucoup l'analyse, le traitement de texte, et les tâches de gestion de données.

En Perl 5, fonctionnalités ont été ajoutées ce complexe de soutien structures de données, fonctions de première classe (c.-à- fermetures en tant que valeurs), et un modèle de programmation orientée objet. Il se agit notamment références, paquets, basée sur la classe méthode expédition, et les variables de portée lexicale, avec directives de compilation (par exemple, le pragma strict). Une caractéristique supplémentaire majeure introduite avec Perl 5 a été la capacité de conditionner le code sous forme de modules réutilisables. Larry Wall a déclaré plus tard que «L'ensemble intention du système de module de Perl 5 était d'encourager la croissance de la culture Perl plutôt que le noyau de Perl."

Toutes les versions de Perl font le typage des données automatique et gestion de la mémoire. L'interprète connaît les exigences de chaque objet de données dans le programme de type et de stockage; il alloue et libère stockage pour eux comme nécessaire à l'aide comptage de référence (de sorte qu'il ne peut pas désallouer structures de données circulaires sans intervention manuelle). Juridiques conversions par exemple le type, les conversions à partir du numéro de chaîne-sont effectuées automatiquement au moment de l'exécution; conversions de type illégales sont des erreurs fatales.

Conception

La conception de Perl peut être comprise comme une réponse à trois grandes tendances dans l'industrie informatique: la baisse des coûts de matériel, la hausse des coûts du travail, et des améliorations dans la technologie de compilateur. Beaucoup de langages informatiques antérieurs, tels que Fortran et C, ont été conçus pour faire un usage efficace de matériel informatique coûteux. En revanche, Perl est conçu pour une utilisation efficace des programmeurs informatiques coûteux.

Perl possède de nombreuses fonctionnalités qui facilitent la tâche du programmeur au détriment des plus grandes exigences en matière de CPU et de mémoire. Il se agit notamment de gestion automatique de la mémoire; typage dynamique; chaînes, les listes et les tables de hachage; expressions régulières; introspection et une fonction eval ().

Mur a été formé en tant que linguiste, et la conception de Perl est très informé par des principes linguistiques. Des exemples comprennent Codage de Huffman (constructions communes doivent être courts), bonne fin pondération (l'information importante devrait venir en premier), et une grande collection de primitifs linguistiques. Perl favorise constructions de langage concis et naturel pour l'homme à lire et écrire, même se ils compliquent l'interpréteur Perl.

Syntaxe Perl reflète l'idée que «les choses qui sont différentes devrait être différent". Par exemple, scalaires, les tableaux et les hachages ont leader différente sceaux. indices de tableau et les clés de hachage utilisent différents types d'accolades. Cordes et les expressions régulières ont des séparateurs standard. Cette approche peut être comparée avec les langues comme Lisp, où le même Construction S-expression et syntaxe de base est utilisé à de nombreuses fins différentes.

Perl ne applique pas tout paradigme de programmation particulier (procédure, orienté objet, fonctionnelle, etc.) ou même exige le programmeur de choisir parmi eux.

Il existe un large plié pratique à la fois au langage Perl et la communauté et de la culture qui l'entourent. La préface à la programmation Perl commence, "Perl est un langage pour obtenir votre travail." Une conséquence de ceci est que Perl ne est pas une langue bien rangé. Il comprend de nombreuses fonctionnalités, tolère des exceptions à ses règles, et emploie heuristiques pour résoudre les ambiguïtés syntaxiques. En raison de la nature de pardon du compilateur, des bogues peuvent parfois être difficiles à trouver. Discuter le comportement de variante de fonctions intégrées dans la liste et scalaires contextes, le perlfunc (1) page de manuel dit «En général, ils ne ce que vous voulez, sauf si vous voulez la cohérence."

Perl a plusieurs devises qui véhiculent les aspects de sa conception et de l'utilisation. Un est " Il ya plus d'une façon de le faire "(TIMTOWTDI, habituellement prononcé« Tim Toady ') autres sont. "Perl:. La tronçonneuse de la programmation de l'armée suisse Langues» et «Pas de limites inutiles" Un objectif de conception déclaré de Perl est à faire. tâches faciles facile et tâches difficiles possible. Perl a également été appelé "Le Duct Tape de l'Internet".

Il n'y a aucune spécification écrite ou standard pour le langage Perl, et aucun plan pour créer un pour la version actuelle de Perl. Il n'y a eu une mise en œuvre de l'interprète. Ce interprète, avec ses tests fonctionnels, se présente comme une spécification de facto de la langue.

Applications

Perl a applications nombreuses et variées, aggravée par la disponibilité de nombreux modules standard et tiers.

Perl a été utilisé depuis les premiers jours du Web pour écrire scripts CGI. Il est connu comme l'un des "trois P" (avec Python et PHP), les langages dynamiques les plus populaires pour les applications Web. Ce est aussi une partie intégrante de la populaire LAMP pile de la solution pour le développement web. Les grands projets écrits en Perl comprennent Slash, Bugzilla, TWiki et Movable Type. De nombreux sites Web à fort trafic, comme bbc.co.uk, Amazon.com, LiveJournal.com, Ticketmaster.com et IMDb.com utiliser intensivement Perl.

Perl est souvent utilisé comme un la langue de colle, liant ensemble des systèmes et des interfaces qui ne ont pas été spécifiquement conçus pour interopérer et pour "les données munging", ce est à dire, la conversion ou le traitement de grandes quantités de données pour des tâches comme la création de rapports. En fait, ces forces sont intimement liés. La combinaison fait perl un outil tout usage populaire pour les administrateurs système, en particulier les programmes sous forme de courtes peuvent être saisis et exécutés sur un seule ligne de commande.

Avec un degré de soin, code Perl peut être portable sur Windows et Unix. Code Perl portable est souvent utilisé par les fournisseurs de logiciels (deux COTS et sur mesure) pour simplifier l'emballage et l'entretien de la construction de logiciels et scripts de déploiement.

Interfaces utilisateur graphiques (GUI) peuvent être développés en utilisant Perl. En particulier, Perl / Tk est couramment utilisé pour permettre l'interaction de l'utilisateur avec des scripts Perl. Cette interaction peut être synchrone ou asynchrone en utilisant les rappels de mettre à jour l'interface graphique. Pour plus d'informations sur les technologies impliquées voir Tk, Tcl et WxPerl.

Perl est également largement utilisé dans la finance et la bio-informatique , où il est apprécié pour le développement rapide d'applications et le déploiement, et la capacité à gérer de grands ensembles de données.

Exécution

Perl est implémenté comme un interprète de base, écrit en C, avec une grande collection de modules, écrit en Perl et C. La distribution source est, à partir de 2005, 12 MB lorsqu'il est emballé dans un fichier tar et compressé. L'interprète est 150 000 lignes de code C et compile à un exécutable de 1 Mo sur les architectures typiques de la machine. Alternativement, l'interprète peut être compilé pour une bibliothèque de lien et intégré dans d'autres programmes. Il ya près de 500 modules dans la distribution, comprenant 200 000 lignes de Perl et un 350 000 lignes supplémentaires de code C. (Une grande partie du code C dans les modules se compose de tables de codage de caractères.)

L'interprète a une architecture orientée objet. Tous les éléments de langage Perl les scalaires, les tableaux, tables de hachage, coderefs, descripteurs de fichier-sont représentés dans l'interpréteur par des structures C. Les opérations sur ces structures sont définies par une grande collection de macros, typedefs et fonctions; ceux-ci constituent l'API Perl C. L'API Perl peut être déroutant pour les non initiés, mais ses points d'entrée suivre un schéma de nommage cohérent, qui fournit des conseils à ceux qui l'utilisent.

L'exécution d'un programme Perl divise grosso modo en deux phases: lors de la compilation et de l'exécution. Au moment de la compilation, l'interprète analyse le texte du programme dans un arbre de syntaxe. Au moment de l'exécution, il exécute le programme en marchant l'arbre. Le texte est analysé qu'une seule fois, et l'arbre de syntaxe est soumise à l'optimisation avant son exécution, de sorte que la phase d'exécution est relativement efficace. Optimisations de compilation sur l'arbre de syntaxe comprennent pliage constante et la propagation de contexte, mais optimisation de judas est également effectuée. Cependant, lors de la compilation et de l'exécution des phases peuvent nid: BEGIN blocs de code exécutent au moment de la compilation, tandis que le eval fonction lance la compilation en cours d'exécution. Ces deux opérations font implicitement partie d'un certain nombre d'autres-notamment, l' use clause qui charge les bibliothèques, connu en tant que modules Perl, implique un BEGIN bloc.

Perl a une contextuelle grammaire qui peut être affectée par code exécuté lors d'une phase d'exécution intermittente. Par conséquent Perl ne peut pas être analysé par une ligne droite Lex / Yacc lexer / de combinaison de l'analyseur. Au lieu de cela, l'interprète met en œuvre sa propre lexer, qui coordonne avec un modifiée GNU analyseur bison pour résoudre les ambiguïtés de la langue. Il est dit que «seul perl peut analyser Perl", ce qui signifie que seul l' interpréteur Perl (Perl) peut analyser le langage Perl (Perl). La vérité de ce est attestée par les imperfections persistantes d'autres programmes qui se engagent à analyser Perl, comme les analyseurs de code source et auto-pénétrateurs, qui doivent composer non seulement avec les nombreuses façons d'exprimer des constructions syntaxiques sans ambiguïté, mais aussi le fait que Perl ne peut pas être analysé dans le cas général sans l'exécuter. Bien réussi à créer un analyseur Perl à des fins liées aux documents, le projet PPI a déterminé que l'analyse de code Perl comme un document (en conservant son intégrité) et comme code exécutable simultanément était, en effet, pas possible. Plus précisément l'auteur a affirmé que, "analyse Perl souffre de la ' Problème de l'arrêt. "

Perl est distribué avec quelques 120 000 tests fonctionnels. Celles-ci passent dans le cadre du processus de construction normale, et exercent intensivement l'interprète et ses modules de base. Développeurs Perl se appuient sur les tests fonctionnels pour se assurer que les changements à l'interprète ne introduisent pas de bogues; inversement, les utilisateurs de Perl qui voient l'interprète passer ses tests fonctionnels sur leur système peuvent avoir un haut degré de confiance qu'il fonctionne correctement.

Maintien de l'interpréteur Perl est devenu de plus en plus difficile au cours des années. Le code de base est en développement continu depuis 1994. Le code a été optimisé pour les performances au détriment de la simplicité, de clarté et de fortes interfaces internes. De nouvelles fonctionnalités ont été ajoutées, mais la compatibilité ascendante pratiquement complète avec les versions antérieures est maintenue. La taille et la complexité de l'interprète est un obstacle pour les développeurs qui souhaitent travailler.

Disponibilité

Perl est logiciel libre, et est autorisé en vertu de la Licence artistique et le GNU Public License. Général distributions sont disponibles pour la plupart systèmes d'exploitation. Elle est particulièrement répandue sur Unix et Systèmes de type Unix, mais il a été porté à la plupart des plates-formes modernes (et beaucoup obsolètes). Avec seulement six ont signalé exceptions, Perl peut être compilé à partir code source sur tous les Unix-like, Plates-formes POSIX ou autrement compatibles Unix. Cependant, ce est rarement nécessaire, car Perl est inclus dans l'installation par défaut de nombreux systèmes d'exploitation populaires.

En raison de changements inhabituels nécessaires à la Environnement Classic Mac OS, un port spécial appelé MacPerl a été expédié de façon indépendante.

Le CPAN porte une liste complète des plates-formes supportées avec des liens vers les distributions disponibles sur chaque.

Fenêtres

Les utilisateurs de Microsoft Windows installent généralement l'une des distributions binaires natifs de Perl pour Win32, le plus souvent ActivePerl. Compilation de Perl code source sous Windows est possible, mais la plupart des installations ne ont pas le compilateur C nécessaires et de construire des outils. Cela rend également difficile d'installer des modules du CPAN, en particulier ceux qui sont partiellement écrit en C.

Les utilisateurs de la distribution binaire ActivePerl sont donc dépendants des modules fournis dans reconditionnés Module référentiel de ActiveState, qui sont précompilés et peut être installé avec PPM. Les ressources limitées pour maintenir ce dépôt ont été cause de divers problèmes de longue date.

Pour remédier à cela et d'autres problèmes de Perl sur la plate-forme Windows, win32.perl.org a été lancé par Adam Kennedy au nom de La Fondation Perl en Juin 2006. Ce est un site communautaire pour "toutes choses Windows et Perl." Un objectif majeur de ce projet est de fournir des distributions Perl alternatives production-qualité qui incluent un compilateur C embarqué et construire des outils, afin de permettre aux utilisateurs de Windows d'installer des modules directement à partir du CPAN. La distribution de production de la famille est appelée Strawberry Perl, avec la recherche et le travail expérimental fait dans un connexes Répartition Vanilla Perl.

Une autre façon populaire de courir Perl sous Windows est fourni par le Cygwin couche d'émulation. Cygwin fournit un environnement de type Unix sur Windows et les deux perl et cpan sont facilement disponibles sous forme de paquets pré-compilés standard dans le programme d'installation de Cygwin. Depuis Cygwin comprend également la gcc, la compilation de la source Perl est également possible.

Structure de la langue

En Perl, le minimum Bonjour programme mondial peut être écrit comme suit:

 print "Bonjour, monde! \ n"

Cette imprime le chaîne Bonjour, monde! et un saut de ligne, symboliquement exprimé par un n caractère dont l'interprétation est modifié par la précédente caractère d'échappement (une barre oblique inverse).

La forme canonique du programme est légèrement plus prolixe:

 #! / Usr / bin / perl
 print "Bonjour tout le monde! \ n";

Le caractère dièse introduit une commenter en Perl, qui se étend jusqu'à la fin de la ligne de code et est ignoré par le compilateur. Le commentaire utilisé ici est d'un genre particulier: il a appelé le ligne tralala. Cela indique les systèmes d'exploitation Unix-like où trouver l'interpréteur Perl, ce qui permet d'invoquer le programme sans mentionner explicitement perl . (Notez que sur Microsoft Windows des systèmes, des programmes Perl sont généralement invoqué en associant le .pl l'extension avec l'interpréteur Perl. Afin de faire face à de telles circonstances, perl détecte la ligne shebang et analyse pour les commutateurs, de sorte qu'il ne est pas strictement vrai que la ligne de shebang est ignorée par le compilateur.)

La deuxième ligne de la forme canonique comprend un point-virgule, qui est utilisée pour séparer des états en Perl. Avec seulement une seule instruction dans un bloc ou un fichier, un séparateur ne est pas nécessaire, il peut être omis de la forme minimale du programme ou plus généralement de la déclaration finale dans ne importe quel bloc ou fichier. La forme canonique comprend parce qu'il est commun de mettre fin à toute déclaration, même quand il ne est pas nécessaire de le faire, car cela rend plus facile l'édition: code peut être ajouté ou éloigné de la fin d'un bloc ou d'un fichier sans avoir à ajuster des points-virgules.

Version 5.10 de Perl introduit un say fonction qui ajoute implicitement un caractère de nouvelle ligne à sa sortie, rendant le "Bonjour tout le monde" programme minimal encore plus court:

 dire «Bonjour tout le monde! '

Les types de données

Perl a un certain nombre de droits fondamentaux types de données, les plus couramment utilisés et discutés être: scalaires, tableaux, hash, handles de fichiers et sous-programmes:

• Un scalaire est une valeur unique; il peut être un nombre, une chaîne ou une référence
• Une tableau est une collection ordonnée des scalaires
• Un hachage, ou tableau associatif, est une carte à partir de chaînes à scalaires; les cordes sont appelés les touches et les scalaires sont appelés valeurs.
• Un descripteur de fichier est une carte à un fichier, un périphérique ou un tuyau qui est ouvert pour la lecture, l'écriture, ou les deux.
• Un sous-programme est un morceau de code qui peuvent être transmis arguments, être exécutée, et renvoyer des données

La plupart des variables sont marquées par un chef de file sceau, qui identifie le type de données en cours d'accès (pas le type de la variable elle-même), à l'exception des handles de fichiers, qui ne ont pas un sceau. Le même nom peut être utilisé pour les variables de différents types de données, sans conflit.

 Foo $ # un scalaire
 foo # un tableau
 % Foo # un hachage
 FOO # un descripteur de fichier
 & # FOO une constante (mais le & est facultatif)
 & # Foo un sous-programme (mais le & est optionnel)

poignées de fichiers et constantes ne doivent pas être en majuscules, mais ce est une convention commune du fait qu'il n'y a pas sceau pour les désigner. Les deux sont de portée mondiale, mais descripteurs de fichiers sont interchangeables avec des références aux handles de fichiers qui peuvent être stockés dans des scalaires, qui à son tour permis portée lexicale. Faire est encouragée dans Perl Best Practices de Damian Conway. Par commodité, l' open fonction dans Perl 5.6 et plus récent sera autovivify scalaires définis de déposer références de poignée.

Les chiffres sont écrites sous la forme nue; chaînes sont entourées de citations de divers types.

 $ Name = "joe";
 $ Color = 'red';
 
 Nombre1 $ = 42;
 number2 de $ '42' =;
 
 # Ce est évaluée à vrai
 si (nombre1 $ == $ nombre2) {print "Les chiffres et les chaînes de chiffres sont les mêmes!";}
 
 $ Reponse = "La réponse est $ number1"; # interpolation variable: La réponse est 42
 $ Prix = 'Cet appareil coûte $ 42'; # Aucune interpolation apostrophes
 
 $ Album = "Ce est la \ de David Bowie" Heroes \ ""; # citations littérales à l'intérieur d'une chaîne;
 $ Album = 'C \' David Bowie l \ 's "Heroes"'; # même que ci-dessus avec des guillemets simples;
 $ Album = q ('s David Bowie' s "Heroes" Il); # la citation comme opérateurs q () et qq () permettent
  # Presque ne importe quel délimiteur au lieu de citations, à
  # Éviter backslashing excessive
 
 Multilined_string $ = <  
 

Perl convertir des chaînes en nombres et vice versa en fonction du contexte dans lequel ils sont utilisés. Dans l'exemple suivant l'$ cordes n et m $ sont traités comme des numéros quand ils sont les arguments à l'opérateur d'addition. Ce code imprime le nombre «5», la suppression des informations non numérique pour l'opération, bien que les valeurs des variables demeurent les mêmes. (L'opérateur de concaténation est la période, pas le + symbole.)

 $ N = "3 pommes»;
 m $ = '2 oranges »;
 print $ n + m $;

Perl dispose également d'un contexte booléen qu'il utilise dans l'évaluation des instructions conditionnelles. Les valeurs suivantes tous les évaluent comme faux en Perl:

 $ False = 0; # le nombre zéro
 $ False = 0,0; # le nombre zéro comme un flotteur
 $ False = 0b0; # le nombre zéro en binaire
 $ False = 0x0; # le nombre zéro en hexadécimal
 $ false = '0'; # la chaîne zéro
 $ False = ""; # la chaîne vide
 $ False = undef; # la valeur de retour du FNUD

Toutes les autres valeurs sont évaluées à true. Cela comprend l'auto-description chaîne littérale impair de "0 but true", qui est en fait 0 comme un nombre, mais vrai lorsqu'il est utilisé comme un booléen. (Toute chaîne non numérique aurait également cette propriété, mais cette chaîne particulière est ignoré par Perl par rapport aux avertissements numériques.) Une version moins explicite mais plus conceptuellement portable de cette chaîne est '0E0' ou '0E0', qui ne est pas compter sur les personnages étant évalué comme 0, comme '0E0' est littéralement "zéro fois dix à la puissance de zéro."

Expressions booléennes évaluées retournent également des valeurs scalaires. Bien que la documentation qui ne promet pas particulièrement vrai ou faux est renvoyé (et ne peuvent donc pas être invoqué), de nombreux opérateurs booléens retour 1 pour vrai et le vide-chaîne pour fausse (qui évalue à zéro dans un contexte numérique). La fonction définie () indique si la variable a un ensemble de valeur. Dans les exemples ci-dessus définies ($ false) est vraie pour toutes les valeurs sauf undef.

Si un résultat spécifiquement 1 ou 0 (comme en C) est nécessaire, une conversion explicite est considéré par certains auteurs à être nécessaire:

 my $ REAL_RESULT = $ boolean_result 1: 0;

Cependant, se il est connu que la valeur est 1 ou undef, une conversion implicite peut être utilisé à la place:

 my $ REAL_RESULT = $ boolean_result + 0;

Une liste est écrit en énumérant ses éléments, séparés par des virgules, et entouré par des parenthèses si requis par la priorité des opérateurs.

 scores = (32, 45, 16, 5);

Il peut être écrit de nombreuses autres manières, certains simples et d'autres moins:

 # Une façon explicite et directe
 scores = ('32', '45', '16', '5');
 
 # Équivalent à ce qui précède, mais le qw () opérateur de devis comme sauve typage des
 # citations et les virgules et réduit l'encombrement visuel;  presque ne importe quel délimiteur peut être
 # Utilisée au lieu de parenthèses
 scores = qw (32 45 16 5);
 
 # La fonction split retourne une liste de chaînes, qui sont extraites
 # À partir de l'expression en utilisant un modèle de regex.
 # Cela peut être utile pour la lecture d'un fichier de valeurs séparées par des virgules (CSV)
 scores = split /, /, '32, 45,16,5 ';
 
 # Il est également possible d'utiliser un postfix pour l'opérateur et d'aliasing
 # $ _ La magie variable à la valeur suivante de la liste lors de chaque
 # Itération;  ce est inutile ici, mais idiomes similaires sont largement utilisés
 # Dans certaines circonstances.
 pousserscores, foreach $ _ 32, 45, 16, 5;

Un hachage peut être initialisé à partir d'une liste de paires clé / valeur:

 % Préféré = (
  joe => «rouge»,
  sam => 'blue'
 );

Le => opérateur équivaut à une virgule, sauf qu'il assume les guillemets autour du jeton précédent, si elle est un identificateur nue: (joe => 'red') est le même que ('joe' => 'red') . Il peut donc être utilisé pour elide guillemets, l'amélioration de la lisibilité.

Les différents éléments d'une liste sont accessibles en fournissant un index numérique, entre crochets. Les valeurs individuelles dans un hachage sont accessibles en fournissant la touche correspondante, entre accolades. Le $ sceau identifie l'élément accessible comme un scalaire.

 $ scores [2] # un élément descores
 $ Préférée {} # joe une valeur en% préférée

Ainsi, un hachage peut également être spécifié par l'établissement de ses touches individuellement:

 {$ Préférée joe} = 'red';
 {$ Préférée sam} = 'blue';

Plusieurs éléments peuvent être accessibles en utilisant le @ sceau place (identifiant le résultat sous forme de liste).

 scores [2, 3, 1] # trois éléments descores
 favorite {'joe', 'Sam'} # deux valeurs en% préférée
 favorite {qw (joe sam)} # même que ci-dessus

Le nombre d'éléments dans un tableau peut être obtenue en évaluant le tableau dans un contexte scalaire ou avec l'aide de l' $# sceau. Ce dernier donne l'indice du dernier élément du tableau, et non le nombre d'éléments. Remarque: le la coloration syntaxique dans le logiciel de Wikipedia considère à tort comme une partie du code ci-dessous pour faire partie des commentaires.

 $ Count =friends; # Affectation à un contexte scalaire des forces scalaire
 
 # $ amis; # L'indice du dernier élément dansfriends
 # $ Amis + 1; # Habituellement, le nombre d'éléments dans unefriends est plus
  # De $ # amis parce que le premier élément est à l'indice 0,
  # Pas une, à moins que le programmeur réinitialiser cette à un autre
  # Valeur, qui découragent la plupart des manuels de Perl.

Il ya quelques fonctions qui opèrent sur des hashs entières.

 names = keys% carnet d'adresses;
 addresses = valeurs% carnet d'adresses;
 
 # Chaque appel à chacun renvoie la paire clé / valeur suivante.
 # Toutes les valeurs seront éventuellement retournés, mais leur ordre
 # Ne peut pas être prédit.
 while (($ nom, $ address) = chaque carnet d'adresses de%) {
  print "$ nom vit à l'adresse $ \ n";
 }
 
 # Comme ci-dessus, mais par ordre alphabétique
 foreach my $ next_name (clés de tri% carnet d'adresses) {
  print "$ next_name vit au carnet d'adresses $ {$ next_name} \ n";
 }

Les structures de contrôle

Perl dispose de plusieurs types de structures de contrôle.

Il possède des structures de contrôle orientés blocs, similaires à celles de la C, Javascript et Java langages de programmation. Conditions sont entourés par des parenthèses, et des blocs contrôlés sont entourés par des accolades:

 étiquette tout (cond) {...}
 étiquette tout (cond) {...} continue {...}
 étiqueter pour (init-expr; cond-expr; incr-expr) {...}
 var étiquette foreach (liste) {...}
 var étiquette foreach (liste) {...} continue {...}
 if (cond) {...}
 if (cond) {...} else {...}
 if (cond) {...} elsif (cond) {...} else {...}

Où une seule déclaration est contrôlée, modificateurs des états fournissent une syntaxe plus concise:

 déclaration if cond;
 déclaration à moins cond;
 déclaration tout cond;
 déclaration jusqu'à ce cond;
 liste foreach de déclaration;

Court-circuit opérateurs logiques sont couramment utilisés pour affecter le flux de contrôle au niveau de l'expression:

 expr et expr
 expr && expr
 expr ou expr
 expr || expr

(La "et" et "ou" opérateurs sont similaires à && et || mais ont inférieure priorité, ce qui rend plus facile de les utiliser pour contrôler les états entiers.)

Les mots-clés de contrôle de flux next (correspondant à C de continue ), last (correspondant à C de break ), return , et redo sont des expressions, de sorte qu'ils peuvent être utilisés avec les opérateurs de court-circuit.

Perl possède également deux structures de boucle implicites, dont chacune a deux formes:

 Résultats = grep {...} liste
 Résultats = expr grep, liste
 Résultats = map {...} liste
 Résultats = expr carte, liste

grep renvoie tous les éléments de la liste pour laquelle le canton contrôlé ou l'expression est évaluée à true. map évalue le canton contrôlé ou une expression pour chaque élément de la liste et retourne une liste des valeurs résultantes. Ces constructions permettent simple style de programmation fonctionnelle.

Jusqu'à la libération 5.10.0, il n'y avait pas instruction switch en Perl 5. De 5.10.0 partir, une déclaration de branche multi-way appelé given / when est disponible, qui prend la forme suivante:

donné (expr) {quand (cond) {...} default {...}}

Syntaxiquement, cette structure se comporte de façon similaire à basculer de trouver dans d'autres langues déclaration, mais avec quelques différences importantes. Le plus important est que, contrairement aux structures switch / cas, étant donné / lorsque les états cassent exécution après la première branche de succès, plutôt que d'attendre pour les commandes de rupture explicitement définies. Inversement, continue explicite sont la place nécessaire pour émuler le comportement de commutation.

Pour ceux qui ne l'aide de la version 5.10.0, la documentation Perl décrit une demi-douzaine de façons d'atteindre le même effet en utilisant d'autres structures de contrôle. Il existe également un Commutateur module, qui fournit des fonctionnalités sur le modèle de la prochaine Perl 6 re-conception. Il est mis en œuvre en utilisant un filtre source, son utilisation est déconseillée officieusement.

Perl comprend une étiquette goto déclaration, mais il est rarement utilisé. Situations où un aller à est appelé dans d'autres langues ne se produisent pas aussi souvent en Perl en raison de l'étendue de ses options de contrôle de flux.

Il ya aussi une goto et sous déclaration qui effectue un appel de queue. Il met fin à la sous-routine actuelle et appelle immédiatement le spécifié sous . Il est utilisé dans les situations où un appelant peut effectuer plus efficace la gestion de la pile que Perl lui-même (généralement parce qu'aucun changement à la pile actuelle est requise), et la récursivité profonde queue appelant peut avoir un impact positif important sur ​​les performances car il évite la surcharge de portée / empiler gestion sur le retour.

Les sous-programmes

Les sous-programmes sont définis avec le sous mot-clé, et invoquée tout simplement en les nommant. Si le sous-programme en question n'a pas encore été déclarée, l'invocation nécessite soit des parenthèses après le nom de la fonction ou une esperluette ( & ) devant elle. Mais l'aide et sans parenthèses passera aussi implicitement les arguments de la sous-routine actuelle de celui qui est appelé, et l'utilisation et avec des parenthèses contournera prototypes.

# Appeler un sous-
 
# parenthèses sont requises ici si le sous-programme est défini plus tard dans le codefoo() ;
& foo ; # (Ceci fonctionne également, mais a d'autres conséquences sur les arguments passés au sous-programme)
 
# Définir un sous-programme
sousfoo{ .. . }foo; # Voici parenthèses ne sont pas nécessaires

Une liste d'arguments peut être fournie après le nom du sous-programme. Les arguments peuvent être des scalaires, des listes ou des hashs.

foo$ x , @ y , z% ;

Les paramètres à un sous-programme ne doivent être déclarées que soit nombre ou le type; en fait, ils peuvent varier d'un appel à. Toute la validation des paramètres doit être effectuée de manière explicite dans la routine.

Les tableaux sont étendus à leurs éléments, hashes sont étendues à une liste de paires clé / valeur, et l'ensemble du lot est passé dans le sous-programme comme une seule liste de scalaires.

Quels que soient les arguments sont passés sont disponibles pour la sous-routine dans le tableau spécial _ . Les éléments de _ sont alias aux arguments réels; changer un élément de _ changement de l'argument correspondant.

Éléments de_peuvent être par les indices de la façon habituelle.

$ _ [ 0 ] , $ _ [ 1 ]

Toutefois, le code résultant peut être difficile à lire, et les paramètres ontpasser par référence sémantique, qui peuvent être indésirables.

Un idiome commun consiste à attribuer_à une liste de variables nommées.

 mon ( $ x , $ y , z $ ) = _ ;

Cela donne les noms de paramètres mnémoniques et met en œuvre la sémantique passer par valeur. Le mon mot-clé indique que les variables suivantes sont portée lexicale au bloc contenant.

Un autre idiome est de déplacer hors de paramètres _ . Cela est particulièrement vrai lorsque le sous-programme prend un seul argument, ou pour la manipulation de l' $ Self argument en modules orientés objet.

ma $ x = shift ;

Les sous-programmes peuvent attribuer _ à un hachage pour simuler les arguments nommés; ce qui est recommandé dans Perl Best Practices pour les sous-programmes qui sont susceptibles d'avoir jamais plus de trois paramètres.

sousfunction1{
 mes % args = _ ;
 impression "'x' argument était '$ args {x}"\\ n" ;
 }function1(x=> 23 ) ;

Les sous-programmes peuvent renvoyer des valeurs.

retour 42 , $ x , @ y , z% ;

Si le sous-programme ne quitte pas via une retour déclaration, puis elle retourne la dernière expression évaluée dans le corps de la routine. Les tableaux et les hashs de la valeur de retour sont étendues à des listes de scalaires, comme ils le sont pour les arguments.

L'expression retournée est évaluée dans le contexte de l'appel du sous-programme; cela peut surprendre les imprudents.

sousla liste{( 4 , 5 , 6 )}
soustableau{ x = ( 4 , 5 , 6 ) ; x }
 
$ x =liste; # renvoie 6 - dernier élément de la liste
$ x =tableau; # rendements 3 - nombre d'éléments dans la liste
x =liste; # renvoie (4, 5, 6)
x =tableau; # renvoie (4, 5, 6)

Un sous-programme peut découvrir son contexte d'appel à lawantarrayfonction.

soussoit{
 retour wantarray ? ( 1 , 2 ) : «Oranges» ;
 }
 
$ x =soit; # retours "Oranges"
x =soit; # renvoie (1, 2)

Expressions régulières

Le langage Perl comprend une syntaxe spécialisée pour écrire des expressions régulières (RE, ou des expressions rationnelles), et l'interprète contient un moteur de recherche des chaînes d'expressions régulières. Le moteur d'expression régulière utilise un algorithme de retour en arrière, l'extension de ses capacités, de la simple correspondance de motif à la capture et à la substitution de chaîne. Le moteur d'expressions régulières est dérivé de regex écrits par Henry Spencer.

La syntaxe d'expression régulière Perl a été prise à partir d'UNIX Version 8 des expressions régulières. Cependant, il a divergé avant la première version de Perl, et a depuis grandi pour inclure beaucoup plus de fonctionnalités. Autres langues et des applications sont en train d'adopter des expressions régulières compatibles Perl plus des expressions régulières POSIX, y compris PHP, Ruby, Java , Microsoft .NET Framework et le serveur HTTP Apache.

Syntaxe d'expression régulière est extrêmement compact, en raison de l'histoire. Les premiers dialectes d'expressions régulières ne sont que légèrement plus expressive que globs, et la syntaxe a été conçu de telle sorte que l'expression ressemblerait le texte il correspond. Cela signifiait en utilisant rien de plus qu'un caractère de ponctuation simple ou une paire de caractères de délimitation pour exprimer les quelques affirmations soutenues. Au fil du temps, l'expressivité des expressions régulières a augmenté énormément, mais la conception de syntaxe n'a jamais été révisée et continue de compter sur la ponctuation. En conséquence, les expressions régulières peuvent être cryptique et extrêmement dense.

Utilisations

Le m // (match) opérateur introduit une expression régulière. (Si elle est délimitée par des barres obliques, comme dans tous les exemples ici, le leader m peut être omise par souci de concision. Si le m est présent, comme dans tous les exemples suivants, d'autres séparateurs peuvent être utilisés à la place des barres obliques.) Dans le plus simple cas, une expression comme

$ X = ~ m /abc/

évalue à truesi et seulement si la chaîne$ Xcorrespond à l'expression régulièreabc.

Les ///(substitut) opérateur, d'autre part, spécifie une recherche et opération de remplacement:

$ X = ~ s / abc / ABC / ; # upcase la b

Une autre utilisation des expressions régulières est de spécifier des séparateurs pour laDiviséfonction:

mots = scission m /, / , $ line ;

La Divisé fonction crée une liste des parties de la chaîne séparés par des matches de l'expression régulière. Dans cet exemple, une ligne est divisée en une liste de ses parties séparées par des virgules, et cette liste est ensuite affecté au mots tableau.

Syntaxe

Parties d'une expression régulière peut être entre parenthèses; parties correspondantes d'une chaîne de correspondance sont capturées . Chaînes capturées sont affectés à la séquentielle variables intégrées 1 $, 2 $, 3 $, ... , et une liste de chaînes capturées est retourné comme la valeur du match.

$ X = ~ (.) m / a c / ; # capturer le caractère entre «a» et «c»

Expressions régulières Perl peuvent prendre modificateurs . Ce sont des suffixes une seule lettre qui modifient le sens de l'expression:

$ X = ~ m / abc / i ; # insensible à la casse correspondance de motif
$ x = ~ s / abc / ABC / g ; # recherche globale et remplacer

Depuis les expressions régulières peuvent être dense et énigmatique à cause de leur syntaxe compacte, le / X modificateur a été ajouté en Perl pour aider les programmeurs écrivent des expressions régulières plus lisibles. Il permet aux programmeurs de placer espaces et des commentaires à l'intérieur des expressions régulières:

$ X = ~ m /a# reconnaît 'a'
 . # suivi d'un caractèrec#, puis suivi par le 'c'character
 /x;

interfaces de base de données

Perl est largement favorisé pour les applications de base de données. Ses installations de manutention du texte sont utiles pour générer des requêtes SQL; tableaux, hashes et la gestion automatique de la mémoire, il est facile de recueillir et de traiter les données renvoyées.

Dans les premières versions de Perl, interfaces de base de données ont été créés par re-lier l'interprète avec une bibliothèque de base de données côté client. Ce fut assez difficile qu'il n'a été fait que pour quelques-unes des bases de données les plus importantes et les plus utilisées, et a restreint le résultant perl exécutable en utilisant une seule interface de base de données à la fois.

En Perl 5, interfaces de base de données sont mises en œuvre par les modules Perl DBI. Le (Database Interface) module DBI présente une interface unique, base de données indépendante pour les applications Perl, tandis que le DBD (Database Driver) modules gèrent les détails de l'accès à quelque 50 bases de données différentes; il ya des pilotes DBD pour la plupart des ANSI bases de données SQL.

DBI fournit la mise en cache pour les poignées et les requêtes de base de données, ce qui peut grandement améliorer les performances dans des environnements d'exécution longue durée de vie tels quemod_perl, aider les systèmes à haut volume détournent pointes de charge comme dans l'effet Slashdot.

Performance comparative

L'ordinateur de compétence linguistique Jeu comparer la performance des implémentations de problèmes de programmation typiques dans plusieurs langages de programmation. Les implémentations Perl présentés étaient généralement vers le haut de gamme du spectre de l'utilisation de la mémoire, et a eu des résultats de vitesse variées. La performance de Perl dans le jeu de repères est similaire à d'autres langages interprétés tels que Python, plus rapide que PHP, et nettement plus rapide que Ruby, mais plus lentement que la plupart des langues compilés.

Programmes Perl peuvent commencer plus lentement que des programmes similaires dans les langages compilés parce perl doit compiler le code source à chaque fois qu'il est exécuté. Dans un discours à l' YAPC :: Europe conférence de 2005 et de l'article suivant, "Un nouveau départ en temps opportun», Jean-Louis Leroy a constaté que ses programmes Perl ont pris beaucoup plus de temps à courir que prévu parce que l'interprète perl a passé beaucoup de temps à trouver parce que les modules de sa plus-grand chemin d'inclusion. Parce pré-compilation est toujours une partie expérimentale de Perl-contrairement à celle de Java, Python, et les programmes Ruby-Perl payer cette pénalité en tête à chaque exécution. Quand amortis sur une phase de long terme, le temps de démarrage est généralement pas importante, mais la mesure de très de courtes durées d'exécution peuvent souvent être faussés comme cela est souvent trouvé dans les benchmarks.

Un certain nombre d'outils ont été mis en place pour améliorer cette situation, dont la première a été d'Apachela mod_perl, qui a cherché à répondre à l'une des raisons les plus courantes que les programmes de petits Perl ont été invoquées rapidement:CGIWeb. développementActivePerl, via MicrosoftISAPI offre des performances similaires améliorations.

Une fois le code Perl est compilé, il ya une charge supplémentaire au cours de la phase d'exécution qui est généralement absente des programmes écrits dans des langages compilés comme C ou C ++, y compris, entre autres choses, les frais généraux en raison de bytecode interprétation, gestion de la mémoire de comptage de références, et type dynamique vérifier.

Optimisation

Programmes Perl, comme tout code, peuvent être accordées pour des performances en utilisant des repères et des profils après une mise en œuvre lisible et correcte est terminée. En partie à cause de la nature interprétée de Perl, l'écriture plus efficace Perl ne sera pas toujours suffisant pour répondre à ses objectifs de performance pour un programme.

Dans de telles situations, les routines les plus critiques d'un programme Perl peuvent être écrits dans d'autres langues telles que C ou assembleur, qui peuvent être connectés à Perl via des modules Inline simples ou plus complexes, mais souple mécanisme XS. Nicholas Clark, un développeur du noyau Perl, Perl traite de certains conception des compromis et des solutions dans Quand perl est pas assez rapide .

Dans les cas extrêmes, l'optimisation de Perl peut nécessiter une connaissance intime des rouages ​​de l'interprète plutôt que les compétences avec des algorithmes, le langage Perl, ou des principes généraux de l'optimisation.

Avenir

En 2000 Conférence Perl, Jon Orwant fait un cas pour une nouvelle initiative majeure de la langue. Cela a conduit à la décision de commencer à travailler sur une refonte de la langue, d'être appelés Perl 6. Propositions pour de nouvelles fonctionnalités de langage ont été sollicitées auprès de la communauté Perl en général, et plus de 300 RFC ont été soumises.

Larry Wall a passé les quelques prochaines années digérer les RFC et les synthétiser dans un cadre cohérent pour Perl 6. Il a présenté son projet pour Perl 6 dans une série de documents appelés «apocalypses», qui sont numérotées pour correspondre aux chapitres de la programmation Perl ( "La Camel Book"). La spécification actuelle, pas encore finalisé de Perl 6 est encapsulé dans les documents de conception appelés synopsis, qui sont numérotées pour correspondre à Apocalypses.

Perl 6 ne vise pas à être rétro-compatible, mais il y aura un mode de compatibilité.

travaux de thèse par Bradley M. Kuhn, supervisé par Larry Wall, considéré comme l'utilisation possible de la machine virtuelle Java comme un runtime pour Perl .. thèse de Kuhn a montré que cette approche est problématique, et en 2001, il a été décidé que Perl 6 courrait sur un cross-language machine virtuelle appelé Parrot. Cela signifie que d'autres langues ciblant le Parrot auront accès natif à CPAN, permettant un certain niveau de développement inter-langues.

En 2005 Audrey Tang a créé le projet de carlins, une implémentation de Perl 6 dans Haskell. Cela a été et continue d'agir comme une plate-forme de test pour le langage Perl 6 (distinct de l'élaboration de la mise en œuvre effective) permettant aux concepteurs de langage à explorer. Le projet de carlins engendré une communauté de langue de croix Perl / Haskell actif centré autour de la chaîne perl6 irc freenode #.

Un certain nombre de fonctions dans le langage Perl 6 montrent maintenant similitudes avec Haskell, et Perl 6 a été adopté par la communauté Haskell comme un langage de script potentiel.

En 2006, Perl 6, Parrot, et carlins sont en cours de développement, et un nouveau module pour Perl 5 appelév6 permet un peu de code Perl 6 pour fonctionner directement sur ​​le dessus de Perl 5.

Développement de Perl 5 se poursuit également. Perl 5.10 a été publié en Décembre 2007, avec quelques nouvelles fonctionnalités influencés par la conception de Perl 6.

La communauté Perl

La culture et la communauté Perl a développé parallèlement à la langue elle-même. Usenet a été le premier lieu public où Perl a été introduit, mais au cours de son évolution, la communauté Perl a été façonnée par la croissance de l'élargissement des services basés sur Internet, y compris l'introduction du Monde Toile Large. La communauté qui entoure Perl était, en fait, le thème de la première «Etat de l'oignon" de Larry Wall parler.

État de l'oignon

État de l'oignon est le nom de chaque année de Larry Wall résumés keynote de style sur les progrès de Perl et de sa communauté. Ils sont caractérisés par son humour caractéristique, employant des références à Perl et la culture des hackers plus large, ainsi que linguistique et parfois son origine chrétienne de mur.

Chaque exposé est d'abord donnée à diverses conférences Perl et éventuellement également publié en ligne.

Passe-temps

Les passe-temps de Perl sont devenus un élément déterminant de la communauté. Parmi elles, des usages triviaux et complexes de la langue.

JAPHs

Dans courriel, Usenet et le message des affectations, "Juste un autre pirate Perl "(JAPH) programmes sont devenus une tendance commune, originaire parRandal L. Schwartz, l'un des premiers formateurs de Perl professionnels.

Dans le langage de la culture Perl, les programmeurs Perl sont connus comme les pirates Perl, et de cette dérive de la pratique de l'écriture des programmes courts d'imprimer la phrase " Juste un autre hacker Perl, ". Dans l'esprit du concept original, ces programmes sont modérément obscurcis et suffisamment court pour tenir dans la signature d'un message électronique ou Usenet. Le JAPH "canonique" comprend la virgule à la fin, même si cela est souvent omise.

Perl de golf

Perl "golf" est le passe-temps de réduire le nombre de caractères utilisés dans un programme Perl au strict minimum, autant que la façon dont terrains de joueurs cherchent à prendre aussi peu de coups que possible dans un tour. Cette utilisation du mot "golf" initialement axée sur les JAPHs utilisés dans les signatures de messages Usenet et d'ailleurs, si les mêmes cascades avaient été un passe-temps sans nom dans la langue APL dans les décennies précédentes. L'utilisation de Perl pour écrire un programme qui a effectué le cryptage RSA a suscité un large intérêt et pratique dans ce passe-temps. Dans les années suivantes, le code de golf a été pris comme un passe-temps dans d'autres langues que Perl.

Obfuscation

Comme C,compétitions de code brouillées sont un passe-temps bien connu. Le rapport annuel Obfuscated concours Perl fait une vertu de la voûte de flexibilité syntaxique de Perl.

Poésie

Semblable au code brouillé et le golf, mais avec un but différent, la poésie Perl est la pratique de l'écriture des poèmes qui peuvent effectivement être compilé comme légale (bien que généralement non-sens) du code Perl. Ce passe-temps est plus ou moins unique de Perl en raison du grand nombre de mots anglais régulières utilisées dans la langue. Nouveaux poèmes sont régulièrement publiés dans la section Perl Poésie de site de Perl Monks.

CPAN Acme

Il ya aussi de nombreux exemples de code écrites purement pour le divertissement sur ​​le CPAN. Lingua :: Romana Perligata , par exemple, permet d'écrire des programmes en latin . Lors de l'exécution d'un tel programme, le module traduit son code source en Perl régulière et l'exécute.

La communauté Perl a mis de côté le « namespace Acme "pour les modules qui sont amusantes dans la nature (mais son champ d'application est élargi pour inclure du code exploratoire ou expérimentale ou tout autre module qui ne se veut jamais être utilisé dans la production). Certains des modules Acme sont délibérément mis en œuvre de façon amusante. Cela inclut Acme de l'eau de Javel , l'un des premiers modules dans le Acme :: namespace, qui permet le code source du programme à être "blanchi" (ie, tous les caractères remplacés par des espaces) et pourtant fonctionnent toujours.