perlintro - En ligne dans le cloud

PROGRAMME:

Nom

perlintro -- une brève introduction et un aperçu de Perl

DESCRIPTION

Ce document est destiné à vous donner un aperçu rapide du langage de programmation Perl,
ainsi que des pointeurs vers une documentation supplémentaire. Il est conçu comme un guide de « bootstrap » pour
ceux qui sont nouveaux dans la langue et fournit juste assez d'informations pour que vous puissiez
lire le Perl d'autres personnes et comprendre à peu près ce qu'il fait, ou écrire le vôtre
des scripts simples.

Ce document introductif n’a pas vocation à être complet. Il ne vise même pas à être
tout à fait exact. Dans certains cas, la perfection a été sacrifiée dans le but d'obtenir
l'idée générale à travers. Tu es fortement conseillé de suivre cette introduction avec plus
informations du manuel Perl complet, dont la table des matières se trouve dans
perltoc.

Tout au long de ce document, vous verrez des références à d'autres parties de la documentation Perl.
Vous pouvez lire cette documentation en utilisant la commande "perldoc" ou quelle que soit la méthode utilisée.
utiliser pour lire ce document.

Tout au long de la documentation Perl, vous trouverez de nombreux exemples destinés à expliquer
les fonctionnalités discutées. Veuillez garder à l'esprit que beaucoup d'entre eux sont plutôt des fragments de code.
que des programmes complets.

Ces exemples reflètent souvent le style et les préférences de l'auteur de ce morceau du
documentation, et peut être plus brève qu'une ligne de code correspondante dans un programme réel.
Sauf indication contraire, vous devez supposer que « utiliser strict » et « utiliser des avertissements »
les instructions apparaissent plus tôt dans le "programme" et que toutes les variables utilisées ont déjà été
déclaré, même si ces déclarations ont été omises pour rendre l'exemple plus facile à lire.

Notez que les exemples ont été rédigés par de nombreux auteurs différents sur une période de
plusieurs décennies. Les styles et les techniques seront donc différents, même si certains efforts ont été déployés.
été conçu pour ne pas trop varier les styles dans les mêmes sections. Ne considérez pas un seul style
être meilleur que les autres - "Il y a plus d'une façon de le faire" est l'une des devises de Perl.
Après tout, au cours de votre parcours en tant que programmeur, vous rencontrerez probablement différents styles.

Ce que is Perl?
Perl est un langage de programmation à usage général développé à l'origine pour la manipulation de texte.
et maintenant utilisé pour un large éventail de tâches, notamment l'administration système, le développement Web,
programmation réseau, développement d'interface graphique, etc.

Le langage se veut pratique (facile à utiliser, efficace, complet) plutôt que
beau (minuscule, élégant, minimal). Ses principales caractéristiques sont sa simplicité d'utilisation,
prend en charge la programmation procédurale et orientée objet (OO), possède de puissants composants intégrés
prend en charge le traitement de texte et possède l'une des collections de logiciels les plus impressionnantes au monde.
modules tiers.

Différentes définitions de Perl sont données dans perl, perlfaq1 et sans doute ailleurs. Depuis
cela nous permet de déterminer que Perl représente des choses différentes pour différentes personnes, mais que beaucoup de
les gens pensent que cela vaut au moins la peine d’en parler.

Fonctionnement Perl tout proche.
Pour exécuter un programme Perl à partir de la ligne de commande Unix :

nom de programme perl.pl

Vous pouvez également mettre ceci comme première ligne de votre script :

#!/ usr / bin / env perl

... et exécutez le script comme /chemin/vers/script.pl. Bien sûr, il faudra qu'il soit exécutable
d'abord, donc "chmod 755 script.pl" (sous Unix).

(Cette ligne de départ suppose que vous avez le env programme. Vous pouvez également mettre directement le chemin vers
votre exécutable Perl, comme dans "#!/usr/bin/perl").

Pour plus d'informations, y compris des instructions pour d'autres plates-formes telles que Windows et Mac
Système d'exploitation, lisez perlrun.

Sécurité net
Perl par défaut est très indulgent. Afin de le rendre plus robuste, il est recommandé de
démarrez chaque programme avec les lignes suivantes :

#!/usr/bin/perl
utiliser strict;
utiliser des avertissements ;

Les deux lignes supplémentaires demandent à Perl de détecter divers problèmes courants dans votre code.
Ils vérifient différentes choses, vous avez donc besoin des deux. Un problème potentiel détecté par « use strict ; »
entraînera l'arrêt immédiat de votre code lorsqu'il est rencontré, tandis que "use warns;"
donnera simplement un avertissement (comme le commutateur de ligne de commande -w) et laissez votre code s'exécuter. À
pour en savoir plus à leur sujet, consultez leurs pages de manuel respectives dans strict et avertissements.

Basic syntaxe vue d'ensemble
Un script ou un programme Perl se compose d'une ou plusieurs instructions. Ces déclarations sont simplement
écrit dans le script de manière simple. Il n'est pas nécessaire d'avoir un "main()"
fonction ou quoi que ce soit de ce genre.

Les instructions Perl se terminent par un point-virgule :

imprimer « Bonjour tout le monde » ;

Les commentaires commencent par un symbole dièse et vont jusqu'à la fin de la ligne

# Ceci est un commentaire

Les espaces ne sont pas pertinents :

impression
"Bonjour le monde"
;

... sauf à l'intérieur des chaînes entre guillemets :

# cela s'imprimerait avec un saut de ligne au milieu
imprimer "Bonjour
monde";

Des guillemets doubles ou simples peuvent être utilisés autour des chaînes littérales :

imprimer « Bonjour tout le monde » ;
imprimer « Bonjour tout le monde » ;

Cependant, seuls les guillemets doubles « interpolent » les variables et les caractères spéciaux tels que
nouvelles lignes ("\n") :

print "Bonjour, $name\n" ; # fonctionne bien
print 'Bonjour, $nom\n'; # imprime $name\n littéralement

Les nombres n'ont pas besoin d'être entourés de guillemets :

imprimer 42 ;

Vous pouvez utiliser des parenthèses pour les arguments des fonctions ou les omettre selon vos préférences personnelles.
goût. Ils ne sont requis qu’occasionnellement pour clarifier des questions de préséance.

print("Bonjour tout le monde\n");
print "Bonjour tout le monde\n" ;

Des informations plus détaillées sur la syntaxe Perl peuvent être trouvées dans perlsyn.

Perl variable types
Perl a trois types de variables principaux : les scalaires, les tableaux et les hachages.

Scalaires
Un scalaire représente une valeur unique :

mon $animal = "chameau" ;
ma $réponse = 42 ;

Les valeurs scalaires peuvent être des chaînes, des entiers ou des nombres à virgule flottante, et Perl le fera.
convertir automatiquement entre eux selon les besoins. Il n'est pas nécessaire de pré-déclarer votre
types de variables, mais vous devez les déclarer en utilisant le mot-clé "my" la première fois que vous
Utilise les. (C'est l'une des exigences de « use strict ; ».)

Les valeurs scalaires peuvent être utilisées de différentes manières :

imprimer $animal;
print "L'animal est $animal\n";
print "Le carré de $answer est ", $answer * $answer, "\n";

Il existe un certain nombre de scalaires « magiques » dont les noms ressemblent à des signes de ponctuation ou à des lignes.
bruit. Ces variables spéciales sont utilisées à toutes sortes de fins et sont documentées
en perlvar. Le seul que vous devez connaître pour l'instant est $_ qui est le "par défaut
variable". Il est utilisé comme argument par défaut pour un certain nombre de fonctions en Perl, et
il est défini implicitement par certaines constructions en boucle.

imprimer; # imprime le contenu de $_ par défaut

Arrays
Un tableau représente une liste de valeurs :

mes @animaux = ("chameau", "lama", "hibou");
mes @numéros = (23, 42, 69);
mon @mixed = ("chameau", 42, 1.23);

Les tableaux sont indexés à zéro. Voici comment accéder aux éléments d’un tableau :

imprimer $animaux[0]; # imprime "chameau"
imprimer $animaux[1]; # imprime "lama"

La variable spéciale $#array vous indique l'index du dernier élément d'un tableau :

imprimer $mixed[$#mixed]; # dernier élément, imprime 1.23

Vous pourriez être tenté d'utiliser "$#array + 1" pour vous indiquer le nombre d'éléments contenus dans un
tableau. Ne vous embêtez pas. En l'occurrence, en utilisant @array où Perl s'attend à trouver un scalaire
value ("dans un contexte scalaire") vous donnera le nombre d'éléments dans le tableau :

si (@animaux < 5) { ... }

Les éléments que nous obtenons du tableau commencent par un "$" car nous obtenons simplement
une seule valeur hors du tableau ; vous demandez un scalaire, vous obtenez un scalaire.

Pour obtenir plusieurs valeurs d'un tableau :

@animaux[0,1]; # donne ("chameau", "lama");
@animaux[0..2]; # donne ("chameau", "lama", "hibou");
@animaux[1..$#animaux]; # donne tout sauf le premier élément

C'est ce qu'on appelle une « tranche de tableau ».

Vous pouvez effectuer diverses opérations utiles sur les listes :

mon @sorted = trier @animaux;
mon @backwards = inverser les @numbers ;

Il existe également quelques tableaux spéciaux, tels que @ARGV (les arguments de ligne de commande pour
votre script) et @_ (les arguments passés à un sous-programme). Ceux-ci sont documentés dans
pervar.

Des hachis
Un hachage représente un ensemble de paires clé/valeur :

my %fruit_color = ("pomme", "rouge", "banane", "jaune");

Vous pouvez utiliser des espaces et l'opérateur "=>" pour les disposer plus joliment :

mon %fruit_color = (
pomme => "rouge",
banane => "jaune",
);

Pour accéder aux éléments de hachage :

$fruit_color{"pomme"} ; # donne "rouge"

Vous pouvez accéder à des listes de clés et de valeurs avec "keys()" et "values()".

mes @fruits = clés %fruit_colors ;
mes @colors = valeurs %fruit_colors ;

Les hachages n'ont pas d'ordre interne particulier, bien que vous puissiez trier les clés et effectuer une boucle
à travers eux.

Tout comme les scalaires et les tableaux spéciaux, il existe également des hachages spéciaux. Le plus bien
le plus connu est %ENV qui contient des variables d'environnement. Lisez tout à ce sujet (et
autres variables spéciales) dans perlvar.

Les scalaires, les tableaux et les hachages sont documentés plus en détail dans perldata.

Des types de données plus complexes peuvent être construits à l'aide de références, ce qui vous permet de créer
listes et hachages dans les listes et les hachages.

Une référence est une valeur scalaire et peut faire référence à tout autre type de données Perl. Ainsi, en stockant un
référence comme valeur d'un tableau ou d'un élément de hachage, vous pouvez facilement créer des listes et des hachages
dans les listes et les hachages. L'exemple suivant montre un hachage à 2 niveaux de structure de hachage
en utilisant des références de hachage anonymes.

mes $variables = {
scalaire => {
description => "élément unique",
sceau => '$',
},
tableau => {
description => "liste ordonnée des éléments",
sceau => '@',
},
hachage => {
description => "paires clé/valeur",
sceau => '%',
},
};

print "Les scalaires commencent par $variables->{'scalar'}->{'sigil'}\n";

Des informations complètes sur le thème des références peuvent être trouvées dans perlreftut, perllol,
perlref et perldsc.

Variable portée
Tout au long de la section précédente, tous les exemples ont utilisé la syntaxe :

mon $var = "valeur" ;

Le « mon » n’est en fait pas obligatoire ; vous pouvez simplement utiliser :

$var = "valeur" ;

Cependant, l'utilisation ci-dessus créera des variables globales dans tout votre programme, ce qui est
mauvaise pratique de programmation. "my" crée à la place des variables de portée lexicale. Les variables
sont limités au bloc (c'est-à-dire un ensemble d'instructions entourées d'accolades) dans lequel
ils sont définis.

mon $x = "foo" ;
mon $some_condition = 1 ;
si ($une_condition) {
mon $y = "barre" ;
imprimer $x ; # affiche "foo"
imprimer $y ; # imprime "bar"
}
imprimer $x ; # affiche "foo"
imprimer $y ; # n'imprime rien ; $y est hors de portée

Utiliser « mon » en combinaison avec « use strict ; » en haut de vos scripts Perl signifie que
l'interprète détectera certaines erreurs de programmation courantes. Par exemple, dans le
exemple ci-dessus, le "print $y" final provoquerait une erreur de compilation et vous empêcherait de
exécuter le programme. L'utilisation de « strict » est fortement recommandée.

Conditionnel ainsi que en boucle constructions
Perl possède la plupart des constructions conditionnelles et en boucle habituelles. Depuis Perl 5.10, il est même
a une instruction case/switch (écrite "given"/"when"). Voir « Instructions Switch » dans Perlsyn
pour plus de détails.

Les conditions peuvent être n'importe quelle expression Perl. Voir la liste des opérateurs dans la section suivante
pour plus d'informations sur les opérateurs de comparaison et de logique booléenne, qui sont couramment utilisés dans
expressions conditionnelles.

if
si ( condition ) {

} elsif ( autre condition ) {

} Else {

}

Il existe également une version niée :

à moins que (condition) {

}

Ceci est fourni sous la forme d'une version plus lisible de "if (!condition)".

Notez que les accolades sont obligatoires en Perl, même si vous n'avez qu'une seule ligne dans le fichier
bloc. Cependant, il existe un moyen astucieux de rendre vos blocs conditionnels sur une ligne plus
Anglais comme :

# la manière traditionnelle
si ($zippy) {
imprimer "Ouais!";
}

# la méthode Perlish post-condition
imprimez "Yow!" si $zippy ;
imprimez "Nous n'avons pas de bananes" sauf si $bananes ;

tout en
pendant que ( condition ) {

}

Il existe également une version niée, pour la même raison que nous avons "sauf si" :

jusqu'à (condition) {

}

Vous pouvez également utiliser « while » dans une post-condition :

imprimer "LA LA LA\n" tandis que 1 ; # boucles pour toujours

pour Exactement comme C :

pour ($i = 0; $i <= $max; $i++) {

}

Le style C pour la boucle est rarement nécessaire en Perl puisque Perl fournit le style le plus convivial
liste scannant la boucle "foreach".

foreach
foreach (@tableau) {
print "Cet élément est $_\n";
}

print $list[$_] foreach 0 .. $max;

# vous n'êtes pas non plus obligé d'utiliser le $_ par défaut...
foreach ma $key (clés %hash) {
print "La valeur de $key est $hash{$key}\n";
}

Le mot-clé « foreach » est en fait un synonyme du mot-clé « for ». Voir ""Pour chaque
Boucles" en perlsyn".

Pour plus de détails sur les constructions en boucle (et certaines qui n'ont pas été mentionnées dans cet aperçu)
voir Perlsyn.

Intégré opérateurs ainsi que fonctions
Perl est livré avec une large sélection de fonctions intégrées. Certains de ceux que nous avons déjà
Les éléments vus incluent « imprimer », « trier » et « inverser ». Une liste d'entre eux est donnée au début de
perlfunc et vous pouvez facilement en savoir plus sur n'importe quelle fonction donnée en utilisant "perldoc -f
nom de la fonction".

Les opérateurs Perl sont entièrement documentés dans perlop, mais voici quelques-uns des plus courants
les uns:

Arithmétique
+ ajout
- soustraction
* multiplication
/ division

Comparaison numérique
== égalité
!= inégalité
< Inférieur à
> supérieur à
<= inférieur ou égal
>= supérieur ou égal

Comparaison de chaînes
égalité d'équation
ne l'inégalité
C'est moins que
gt supérieur à
le inférieur ou égal
ge supérieur ou égal

(Pourquoi avons-nous des comparaisons numériques et de chaînes distinctes ? Parce que nous n'avons pas
types de variables spéciaux, et Perl a besoin de savoir s'il doit trier numériquement (où 99
est inférieur à 100) ou par ordre alphabétique (où 100 précède 99).

Logique booléenne
&& et
|| ou
! ne pas

(« et », « ou » et « non » ne figurent pas uniquement dans le tableau ci-dessus en tant que descriptions du
les opérateurs. Ils sont également pris en charge en tant qu'opérateurs à part entière. Ils sont plus
lisible que les opérateurs de style C, mais ont une priorité différente de "&&" et
amis. Consultez Perlop pour plus de détails.)

Divers
= affectation
. concaténation de chaînes
x multiplication de chaîne
.. opérateur de plage (crée une liste de nombres ou de chaînes)

De nombreux opérateurs peuvent être combinés avec un "=" comme suit :

$une += 1 ; # identique à $a = $a + 1
$une -= 1 ; # identique à $a = $a - 1
$a .= "\n"; # identique à $a = $a . "\n" ;

Fichiers ainsi que I / O
Vous pouvez ouvrir un fichier pour une entrée ou une sortie à l'aide de la fonction "open()". C'est documenté dans
détail extravagant dans perlfunc et perlopentut, mais en bref :

open(my $in, "<", "input.txt") ou die "Impossible d'ouvrir input.txt : $!";
open(my $out, ">", "output.txt") ou die "Impossible d'ouvrir output.txt : $!";
open(my $log, ">>", "my.log") ou die "Impossible d'ouvrir mon.log : $!";

Vous pouvez lire à partir d'un descripteur de fichier ouvert à l'aide de l'opérateur "<>". Dans un contexte scalaire, il se lit
une seule ligne du descripteur de fichier, et dans un contexte de liste, il lit l'intégralité du fichier,
affecter chaque ligne à un élément de la liste :

ma ligne $ = <$in> ;
mes @lines = <$in>;

La lecture de l'intégralité du fichier en une seule fois est appelée slurping. Cela peut être utile mais c'est peut-être le cas
un porc à la mémoire. La plupart des traitements de fichiers texte peuvent être effectués ligne par ligne avec le bouclage de Perl.
construit.

L'opérateur "<>" est le plus souvent vu dans une boucle "while" :

while (<$in>) { # attribue chaque ligne tour à tour à $_
print "Il suffit de lire cette ligne : $_" ;
}

Nous avons déjà vu comment imprimer sur une sortie standard en utilisant "print()". Cependant, "print()"
peut également prendre un premier argument facultatif spécifiant sur quel descripteur de fichier imprimer :

print STDERR "Ceci est votre dernier avertissement.\n";
imprimer $out $record ;
imprimer $log $logmessage ;

Lorsque vous avez terminé avec vos descripteurs de fichiers, vous devez les "fermer()" (bien que pour être honnête,
Perl nettoiera après vous si vous oubliez) :

fermez $in ou mourez "$in: $!";

Régulier expressions
La prise en charge des expressions régulières par Perl est à la fois large et approfondie, et fait l'objet de longues recherches.
documentation dans perlrequick, perlretut et ailleurs. Mais en bref :

Correspondance simple
if (/foo/) { ... } # true si $_ contient "foo"
if ($a =~ /foo/) { ... } # true si $a contient "foo"

L'opérateur de correspondance "//" est documenté dans perlop. Il fonctionne sur $_ par défaut, ou
peut être lié à une autre variable à l'aide de l'opérateur de liaison "=~" (également documenté dans
perlop).

Remplacement simple
s/foo/bar/; # remplace foo par bar dans $_
$a =~ s/foo/bar/; # remplace foo par bar dans $a
$a =~ s/foo/bar/g; # remplace TOUTES LES INSTANCES de foo par bar
# dans $a

L'opérateur de substitution "s///" est documenté dans perlop.

Expressions régulières plus complexes
Vous n'êtes pas seulement obligé de faire correspondre des chaînes fixes. En fait, vous pouvez faire correspondre à peu près
tout ce dont vous pourriez rêver en utilisant des expressions régulières plus complexes. Ceux-ci sont
documenté en détail dans perlre, mais en attendant, voici une astuce rapide
drap:

. un seul personnage
\sun caractère d'espacement (espace, tabulation, nouvelle ligne,
...)
\S caractère autre qu'un espace
\da chiffre (0-9)
\D un non-chiffre
\wa caractère de mot (az, AZ, 0-9, _)
\W un caractère autre qu'un mot
[aeiou] correspond à un seul caractère dans l'ensemble donné
[^aeiou] correspond à un seul caractère en dehors de celui donné
set
(foo|bar|baz) correspond à l'une des alternatives spécifiées

^ début de chaîne
$ fin de chaîne

Les quantificateurs peuvent être utilisés pour spécifier la quantité d'éléments précédents que vous souhaitez faire correspondre
on, où « chose » désigne soit un caractère littéral, soit l'un des métacaractères répertoriés
ci-dessus, ou un groupe de caractères ou métacaractères entre parenthèses.

* zéro ou plus de la chose précédente
+ un ou plusieurs des éléments précédents
? zéro ou l'un des éléments précédents
{3} correspond exactement à 3 de la chose précédente
{3,6} correspond entre 3 et 6 de la chose précédente
{3,} correspond à 3 ou plus de la chose précédente

Quelques brefs exemples :

/^\d+/ la chaîne commence par un ou plusieurs chiffres
/^$/ rien dans la chaîne (le début et la fin sont
adjacent)
/(\d\s){3}/ trois chiffres, chacun suivi d'un espace
caractère (par exemple "3 4 5")
/(a.)+/ correspond à une chaîne dans laquelle chaque nombre impair
la lettre est un (par exemple "abacadaf")

# Cette boucle lit depuis STDIN et imprime des lignes non vides :
tandis que (<>) {
suivant si /^$/;
imprimer;
}

Parenthèses pour capturer
En plus du regroupement, les parenthèses ont un deuxième objectif. Ils peuvent être utilisés pour capturer
les résultats de parties de la correspondance d'expression rationnelle pour une utilisation ultérieure. Les résultats finissent par 1 $, 2 $
etc.

# un moyen bon marché et méchant de diviser une adresse e-mail en plusieurs parties

si ($email =~ /([^@]+)@(.+)/) {
print "Le nom d'utilisateur est $1\n" ;
print "Le nom d'hôte est $2\n" ;
}

Autres fonctionnalités d'expression rationnelle
Les expressions rationnelles Perl prennent également en charge les références arrière, les anticipations et toutes sortes d'autres éléments complexes.
détails. Lisez tout à leur sujet dans perlrequick, perlretut et perlre.

Écriture sous-programmes
L'écriture de sous-programmes est simple :

sous-enregistreur {
mon $logmessage = shift ;
ouvrir mon $logfile, ">>", "my.log" ou mourir "Impossible d'ouvrir mon.log : $!";
imprimer $logfile $logmessage ;
}

Nous pouvons maintenant utiliser le sous-programme comme n’importe quelle autre fonction intégrée :

logger("Nous avons un sous-programme de journalisation !");

C'est quoi ce « changement » ? Eh bien, les arguments d'un sous-programme sont à notre disposition sous forme de
tableau appelé @_ (voir perlvar pour en savoir plus). L'argument par défaut du "shift"
il se trouve que la fonction est @_. Donc "mon $logmessage = shift;" décale le premier élément
la liste des arguments et l'attribue à $logmessage.

Nous pouvons également manipuler @_ d'autres manières :

mon ($logmessage, $priority) = @_; # commun
mon $logmessage = $_[0] ; # rare et moche

Les sous-programmes peuvent également renvoyer des valeurs :

sous carré {
mon $num = shift ;
mon $result = $num * $num ;
return $ result;
}

Ensuite, utilisez-le comme :

$ carré = carré(8);

Pour plus d'informations sur l'écriture de sous-programmes, consultez perlsub.

OO Perl
OO Perl est relativement simple et est implémenté à l'aide de références qui savent quel type de
objet, ils sont basés sur le concept de packages de Perl. Cependant, OO Perl est largement au-delà
la portée de ce document. Lisez perlootut et perlobj.

En tant que programmeur Perl débutant, votre utilisation la plus courante d'OO Perl consistera à utiliser des logiciels tiers.
modules de fête, qui sont documentés ci-dessous.

En utilisant Perl modules
Les modules Perl offrent une gamme de fonctionnalités pour vous aider à éviter de réinventer la roue et peuvent
être téléchargé depuis le CPAN ( http://www.cpan.org/ ). Un certain nombre de modules populaires sont
inclus avec la distribution Perl elle-même.

Les catégories de modules vont de la manipulation de texte aux protocoles réseau en passant par la base de données
intégration aux graphiques. Une liste catégorisée de modules est également disponible auprès du CPAN.

Pour savoir comment installer les modules que vous téléchargez depuis le CPAN, lisez perlmodinstall.

Pour apprendre à utiliser un module particulier, utilisez "perldoc Module::Nom". Généralement, vous le ferez
je veux "utiliser Module::Nom", qui vous donnera ensuite accès à des fonctions exportées ou à un OO
interface avec le module.

perlfaq contient des questions et des réponses liées à de nombreuses tâches courantes et fournit souvent
suggestions de bons modules CPAN à utiliser.

perlmod décrit les modules Perl en général. perlmodlib répertorie les modules fournis avec
votre installation Perl.

Si vous ressentez le besoin d'écrire des modules Perl, perlnewmod vous donnera de bons conseils.

Utilisez perlintro en ligne en utilisant les services onworks.net