.\" Automatically generated by Pod::Man 2.16 (Pod::Simple 3.05)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings. \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote. \*(C+ will
.\" give a nicer C++. Capital omega is used to do unbreakable dashes and
.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
. ds -- \(*W-
. ds PI pi
. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
. ds L" ""
. ds R" ""
. ds C` ""
. ds C' ""
'br\}
.el\{\
. ds -- \|\(em\|
. ds PI \(*p
. ds L" ``
. ds R" ''
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD. Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.ie \nF \{\
. de IX
. tm Index:\\$1\t\\n%\t"\\$2"
..
. nr % 0
. rr F
.\}
.el \{\
. de IX
..
.\}
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear. Run. Save yourself. No user-serviceable parts.
. \" fudge factors for nroff and troff
.if n \{\
. ds #H 0
. ds #V .8m
. ds #F .3m
. ds #[ \f1
. ds #] \fP
.\}
.if t \{\
. ds #H ((1u-(\\\\n(.fu%2u))*.13m)
. ds #V .6m
. ds #F 0
. ds #[ \&
. ds #] \&
.\}
. \" simple accents for nroff and troff
.if n \{\
. ds ' \&
. ds ` \&
. ds ^ \&
. ds , \&
. ds ~ ~
. ds /
.\}
.if t \{\
. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
. \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
. \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
. \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
. ds : e
. ds 8 ss
. ds o a
. ds d- d\h'-1'\(ga
. ds D- D\h'-1'\(hy
. ds th \o'bp'
. ds Th \o'LP'
. ds ae ae
. ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "PERLFAQ3 1"
.TH PERLFAQ3 1 "2009-03-16" "DocFr" "User Contributed Perl Documentation"
.\" For nroff, turn off justification. Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NAME/NOM"
.IX Header "NAME/NOM"
perlfaq3 \- Outils de programmation
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
Cette section de la \s-1FAQ\s0 re\*'pond a\*` des questions relatives aux outils de
programmation et a\*` l'aide de programmation.
.Sh "Comment fais-je pour...\ ?"
.IX Subsection "Comment fais-je pour...?"
Avez-vous de\*'ja\*` e\*'te\*' voir le \s-1CPAN\s0 (voir perlfaq2)\ ? Il y a des
chances pour que quelqu'un ait de\*'ja\*` e\*'crit un module susceptible de
re\*'soudre votre proble\*`me. Avez-vous de\*'ja\*` lu les pages man approprie\*'es\ ?
Voila\*` un bref sommaire\ :
.PP
.Vb 11
\& Bases perldata, perlvar, perlsyn, perlop, perlsub
\& Exe\*'cution perlrun, perldebug
\& Fonctions perlfunc
\& Objets perlref, perlmod, perlobj, perltie
\& Structure de donne\*'es perlref, perllol, perldsc
\& Modules perlmod, perlmodlib, perlsub
\& Regexp perlre, perlfunc, perlop, perllocale
\& E\*'voluer vers perl5 perltrap, perl
\& Lier au langage C perlxstut, perlxs, perlcall, perlguts, perlembed
\& Divers http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz
\& (ce n\*(Aqest pas une page man, mais tre\*`s utile)
.Ve
.PP
Un sommaire rudimentaire des pages de manuel de Perl existantes se
trouve dans perltoc.
.Sh "Comment utiliser Perl de fac\*,on interactive\ ?"
.IX Subsection "Comment utiliser Perl de fac,on interactive?"
L'approche typique consiste a\*` utiliser le de\*'bogueur Perl, de\*'crit dans
perldebug, avec un programme \*(L"vide\*(R", comme cela\ :
.PP
.Vb 1
\& perl \-de 42
.Ve
.PP
Maintenant, tapez pluto\*^t un code Perl valide, et il sera imme\*'diatement
e\*'value\*' (exe\*'cute\*'). Vous pouvez e\*'galement examiner la table des
symboles, voir l'e\*'volution de la pile, ve\*'rifier les valeurs des
variables, fixer des points d'arre\*^t, et faire d'autres ope\*'rations
typiquement disponibles dans les de\*'bogueur symboliques.
.Sh "Existe-t-il un shell Perl\ ?"
.IX Subsection "Existe-t-il un shell Perl?"
Le psh (Perl sh) en est a\*` sa version 1.8. C'est un shell qui combine
la nature interactive de shell Unix avec la puissance de Perl. Son but
est d'e\*^tre un shell complet utilisant la syntaxe et les
fonctionnalite\*'s de Perl pour les structures de contro\*^les et d'autres
choses. Vous pouvez re\*'cupe\*'rer psh sur
.
.PP
Zoidberg est un projet similaire qui fournit un shell de\*'veloppe\*' en
perl, configure\*' en perl et utilise\*' en perl. Il peut e\*^tre utilise\*' comme
shell de login et comme shell de de\*'veloppement. Vous pouvez le trouver
sur ou sur votre miroir \s-1CPAN\s0.
.PP
Le module Shell.pm (distribue\*' avec Perl) fait que Perl tente
l'exe\*'cution des commandes qui ne font pas partie du langage Perl en
tant que commandes shell. perlsh de la distribution source est
simpliste et ininte\*'ressant, mais correspondra peut\-e\*^tre a\*` ce que vous
recherchez.
.Sh "Comment puis-je connai\*^tre les modules installe\*'s sur mon syste\*`me ?"
.IX Subsection "Comment puis-je connai^tre les modules installe's sur mon syste`me ?"
Vous pouvez utiliser le module ExtUtils::Installed pour voir toutes
les distributions installe\*'es. Il peut prendre un peu de temps pour
produire sa magie. Les bibliothe\*`ques standards qui viennent avec Perl
sont regroupe\*'es sous le nom \*(L"Perl\*(R" (vous pouvez les voir via
Module::CoreList).
.PP
.Vb 1
\& use ExtUtils::Installed;
\&
\& my $inst = ExtUtils::Installed\->new();
\& my @modules = $inst\->modules();
.Ve
.PP
Si vous souhaitez une liste de tous les noms de fichiers des modules
Perl, vous pouvez utiliser File::Find::Rule.
.PP
.Vb 1
\& use File::Find::Rule;
\&
\& my @files = File::Find::Rule\->file()\->name( \*(Aq*.pm\*(Aq )\->in( @INC );
.Ve
.PP
Si vous ne disposez pas de ce module, vous pouvez obtenir le me\*^me
re\*'sultat via File::Find qui fait partie de la distribution standard.
.PP
.Vb 7
\& use File::Find;
\& my @files;
\& find(
\& sub {
\& push @files, $File::Find::name
\& if \-f $File::Find::name && /\e.pm$/
\& },
\&
\& @INC
\& );
\&
\& print join "\en", @files;
.Ve
.PP
Si vous voulez juste ve\*'rifier rapidement qu'un module est disponible,
vous pouvez chercher sa documentation. Si vous pouvez lire la
documentation d'un module, il y a de grandes chances qu'il soit
installe\*'. Si vous ne le pouvez pas, c'est peut\-e\*^tre que le module n'en
propose pas (dans de tre\*`s rares cas).
.PP
.Vb 1
\& prompt% perldoc Nom::Module
.Ve
.PP
Vous pouvez aussi essayer d'inclure ce module dans un script en une
ligne pour voir si perl le trouve.
.PP
.Vb 1
\& prompt% perldoc \-MNom::Module \-e1
.Ve
.Sh "Comment de\*'boguer mes programmes Perl\ ?"
.IX Subsection "Comment de'boguer mes programmes Perl?"
Avez-vous essaye\*' \f(CW\*(C`use warnings\*(C'\fR ou utilise\*' \f(CW\*(C`\-w\*(C'\fR\ ? Cela permet
d'afficher des avertissements (des warnings) pour de\*'tecter les
pratiques douteuses.
.PP
Avez-vous utilise\*' \f(CW\*(C`use strict\*(C'\fR\ ? Cela vous empe\*^che d'utiliser
des re\*'fe\*'rences symboliques, vous oblige a\*` pre\*'de\*'clarer les
sous-programmes que vous appelez comme simple mot, et (probablement le
plus important) vous oblige a\*` de\*'clarer vos variables avec \f(CW\*(C`my\*(C'\fR,
\&\f(CW\*(C`our\*(C'\fR ou \f(CW\*(C`use vars\*(C'\fR.
.PP
Avez-vous ve\*'rifie\*' les re\*'sultats de chacune des commandes
syste\*`me\ ? Le syste\*`me d'exploitation (et donc Perl) vous indique
si elles ont fonctionne\*' ou pas, et la raison de l'e\*'chec e\*'ventuel.
.PP
.Vb 2
\& open(FH, "> /etc/cantwrite")
\& or die "Couldn\*(Aqt write to /etc/cantwrite: $!\en";
.Ve
.PP
Avez-vous lu perltrap\ ? C'est plein de trucs et astuces pour
les programmeurs Perl de\*'butants ou initie\*'s. Il y a me\*^me des sections
pour ceux d'entre vous qui viennent des langages \fIawk\fR et \fIC\fR.
.PP
Avez-vous essaye\*' le de\*'bogueur Perl, de\*'crit dans perldebug\ ? Vous
pouvez exe\*'cuter votre programme et voir ce qu'il fait, pas a\*` pas et
ainsi comprendre pourquoi ce qu'il fait n'est pas conforme a\*` ce qu'il
devrait faire.
.Sh "Comment mesurer les performances de mes programmes Perl\ ?"
.IX Subsection "Comment mesurer les performances de mes programmes Perl?"
Vous devriez utiliser le module Devel::DProf dans les distributions
standard re\*'centes (ou de \s-1CPAN\s0), ainsi que Benchmark.pm de la
distribution standard. Benchmark vous permet de mesurer le temps
d'e\*'xe\*'cution de portions spe\*'cifiques de votre code alors que
Devel::DProf vous donne des de\*'tails sur les endroits ou\*` le code
consomme du temps.
.PP
Voici un exemple d'utilisation de Benchmark\ :
.PP
.Vb 1
\& use Benchmark;
\&
\& @junk = \`cat /etc/motd\`;
\& $count = 10_000;
\&
\& timethese($count, {
\& \*(Aqmap\*(Aq => sub { my @a = @junk;
\& map { s/a/b/ } @a;
\& return @a },
\& \*(Aqfor\*(Aq => sub { my @a = @junk;
\& local $_;
\& for (@a) { s/a/b/ };
\& return @a },
\& });
.Ve
.PP
Voici l'affichage ge\*'ne\*'re\*' (sur une machine particulie\*`re\*(--vos re\*'sultats
de\*'pendront de votre mate\*'riel, du syste\*`me d'exploitation, et de la
charge de travail de votre machine)\ :
.PP
.Vb 3
\& Benchmark: timing 10000 iterations of for, map...
\& for: 4 secs ( 3.97 usr 0.01 sys = 3.98 cpu)
\& map: 6 secs ( 4.97 usr 0.00 sys = 4.97 cpu)
.Ve
.PP
Soyez conscient qu'un bon benchmark est tre\*`s difficile a\*` e\*'crire. Il ne
teste que les donne\*'es que vous lui passez, et ne prouve vraiment que
peu de choses sur les diffe\*'rences de complexite\*'s entre divers
algorithmes.
.Sh "Comment faire une liste croise\*'e des appels de mon programme Perl\ ?"
.IX Subsection "Comment faire une liste croise'e des appels de mon programme Perl?"
Le module B::Xref peut e\*^tre utilise\*' pour ge\*'ne\*'rer une liste croise\*'e des
appels pour les programmes Perl.
.PP
.Vb 1
\& perl \-MO=Xref[,OPTIONS] scriptname.plx
.Ve
.Sh "Existe-t-il un outil de mise en page de code Perl\ ?"
.IX Subsection "Existe-t-il un outil de mise en page de code Perl?"
Perltidy est un script Perl qui indente et reformate les scripts Perl
pour les rendre plus lisibles en essayant de respecter les re\*`gles de
perlstyle. Si vous e\*'crivez des scripts Perl ou passez beaucoup de
temps a\*` en lire, vous l'appre\*'cierez su\*^rement. Il est disponible sur
.
.PP
Bien su\*^r, si vous respectez les recommandations de perlstyle, vous
ne devriez pas avoir besoin de reformater. L'habitude de formater
votre code au fur et a\*` mesure que vous l'e\*'crivez vous e\*'vitera bien des
erreurs. Votre e\*'diteur devrait vous aider a\*` le faire. Dans emacs, le
perl-mode et son successeur, le cperl-mode, peuvent vous e\*^tre d'une
grande aide pour quasiment tout le code, et me\*^me d'autres e\*'diteurs
moins programmables peuvent vous fournir une assistance
significative. Tom Christiansen et de nombreux utilisateurs de vi ne
jure que par les re\*'glages suivants sous vi et ses clones\ :
.PP
.Vb 2
\& set ai sw=4
\& map! ^O {^M}^[O^T
.Ve
.PP
Placez cela dans votre fichier \fI.exrc\fR (en remplac\*,ant les accents
circonflexes par des caracte\*`res de contro\*^le) et c'est bon. En mode
insertion, ^T est pour l'indentation, ^D pour la suppression de
l'indentation, et ^O pour l'indentation d'un bloc. Un exemple plus
complet, avec des commentaires, peut e\*^tre trouve\*' sur
.
.PP
Le programme a2ps sur
fait
beaucoup pour imprimer des sorties de documents joliment
imprime\*'es. Voyez aussi enscript sur
.
.Sh "Existe-t-il un ctags pour Perl\ ?"
.IX Subsection "Existe-t-il un ctags pour Perl?"
(contribution de brain d foy)
.PP
Exuberent ctags reconnai\*^t Perl : .
.PP
Vous pouvez aussi essayer pltags : .
.Sh "Existe-t-il un environnement de de\*'veloppement inte\*'gre\*' (\s-1IDE\s0) ou un e\*'diteur Perl sous Windows\ ?"
.IX Subsection "Existe-t-il un environnement de de'veloppement inte'gre' (IDE) ou un e'diteur Perl sous Windows?"
Les programmes Perl sont juste du texte donc n'importe quel e\*'diteur
peut convenir.
.PP
Si vous e\*^tes sur Unix, vous disposez de\*'ja\*` d'un \s-1IDE\s0 : Unix lui\-me\*^me. La
philosophie Unix se traduit par un ensemble de petits outils qui
re\*'alisent chacun une seule ta\*^che mais bien. C'est comme une boite a\*`
outils.
.PP
Si vous souhaitez absolument un \s-1IDE\s0, consultez la liste suivante (par
ordre alphabe\*'tique et non par ordre de pre\*'fe\*'rence) :
.IP "Eclipse" 4
.IX Item "Eclipse"
.Sp
Le projet d'inte\*'gration de Perl dans Eclipse propose l'edition et le
de\*'bogage avec Eclipse.
.IP "Enginsite" 4
.IX Item "Enginsite"
.Sp
Perl Editor par EngInSite est un environnement de de\*'veloppement
comple\*`tement inte\*'gre\*' (\s-1IDE\s0) pour cre\*'er, tester et de\*'boguer des scripts
Perl. Il tourne sur Windows 9x/NT/2000/XP ou plus.
.IP "Komodo" 4
.IX Item "Komodo"
.Sp
L'\s-1IDE\s0 d'ActiveState multi-plateformes (en octobre 2004, cela
concernait Windows, Linux et Solaris), multi-langage \s-1IDE\s0 connai\*^t Perl
et inclut un de\*'bogueur d'expressions rationnelles et du de\*'bogage
distant.
.IP "Open Perl \s-1IDE\s0" 4
.IX Item "Open Perl IDE"
.Sp
Open Perl \s-1IDE\s0 est un environnement de de\*'veloppement inte\*'gre\*' permettant
l'e\*'criture et le de\*'bogage de scripts Perl avec la distribution
ActivePerl d'ActiveState sous Windows 95/98/NT/2000.
.IP "OptiPerl" 4
.IX Item "OptiPerl"
.Sp
OptiPerl est un \s-1IDE\s0 Windows permettant la simulation de
l'environnement \s-1CGI\s0 et incluant un de\*'bogueur et un e\*'diteur avec
de\*'coration syntaxique.
.IP "PerlBuilder" 4
.IX Item "PerlBuilder"
.Sp
PerlBuidler est un environnement de de\*'veloppement inte\*'gre\*' pour Windows
qui permet les de\*'veloppement Perl.
.IP "visiPerl+" 4
.IX Item "visiPerl+"
.Sp
De Help Consulting, pour Windows.
.IP "Visual Perl" 4
.IX Item "Visual Perl"
.Sp
Visual Perl est le pug-in Visual Studio.NET d'ActiveState.
.IP "Zeus" 4
.IX Item "Zeus"
.Sp
Zeus pour Window est un autre e\*'diteur/IDE multi-langages pour Win32
qui vient avec le support Perl.
.PP
Pour les e\*'diteurs : si vous e\*^tes sous Unix vous disposez certainement
de vi ou d'un de ses clones et peut\-e\*^tre aussi d'emacs. Vous n'avez
donc rien a\*` te\*'le\*'charger. Dans emacs, le mode cperl-mode (M\-x
cperl-mode) vous fournira un mode d'e\*'dition Perl parmi les meilleurs
de tous les e\*'diteurs.
.PP
Si vous utilisez Windows, vous pouvez utiliser n'importe quel e\*'diteur
qui permet d'e\*'diter du texte brut, tel que NotePad, WordPad ou le
Bloc-Notes. Les traitemens de texte comme Microsoft Word ou
WordPerfect ne fonctionnent pas bien car ils inse\*`rent plein
d'informations cache\*'es (ceci e\*'tant, la plupart proposent aussi
l'enregistrement au format \*(L"Texte seul\*(R"). Vous pouvez aussi
te\*'le\*'charger des e\*'diteurs de textes conc\*,us spe\*'cialement pour la
programmation comme Textpad () et UltraEdit
() entre autres.
.PP
Si vous utilisez MacOS, les me\*^mes conseils s'appliquent. MacPerl (pour
l'envrionnement Classic) vient avec un e\*'diteur simple. Les e\*'diteurs
externes les plus populaires sont BBEdit () or
Alpha (). Les utilisateurs
de MacOS X peuvent aussi utiliser les e\*'diteurs Unix. Neil Bowers
(l'homme derrie\*`re Geekcruises) propose une liste des e\*'diteurs
connaissant Perl sur Mac
().
.IP "\s-1GNU\s0 Emacs" 4
.IX Item "GNU Emacs"
.IP "MicroEMACS" 4
.IX Item "MicroEMACS"
.IP "XEmacs" 4
.IX Item "XEmacs"
.IP "Jed" 4
.IX Item "Jed"
.PP
ou les clones de vi tels :
.IP "Elvis" 4
.IX Item "Elvis"
.IP "Vile" 4
.IX Item "Vile"
.IP "Vim" 4
.IX Item "Vim"
.PP
Pour les amoureux de vi en ge\*'ne\*'ral, sous Windows ou autres :
.PP
.PP
nvi (, disponible sur \s-1CPAN\s0 dans src/misc)
est encore un autre clone de vi, malheureusement sans version Windows,
qui peut e\*^tre inte\*'ressant sur les plateformes Unix car, d'une part, ce
n'est pas a\*` proprement parler un clone de vi mais bien le vrai vi ou
pluto\*^t son e\*'volution et, d'autre part, parce qu'il peut utiliser Perl
comme langage de programmation interne. nvi n'est pas le seul dans ce
cas : vim et vile offrent cette possibilite\*' de Perl inte\*'gre\*'.
.PP
Les programmes suivants sont des e\*'diteurs Win32 multi-langages qui
supportent Perl :
.IP "Codewright" 4
.IX Item "Codewright"
.IP "MultiEdit" 4
.IX Item "MultiEdit"
.IP "SlickEdit" 4
.IX Item "SlickEdit"
.PP
Il existe aussi un petit e\*'diteur de texte gadget e\*'crit en Perl et qui
est distribue\*' dans le module Tk sur \s-1CPAN\s0. ptkdb
() est de\*'bogueur Perl/Tk qui agit un
peu comme une sorte d'environnement de de\*'veloppement. Perl Composer
() est un \s-1IDE\s0 pour la cre\*'ation
d'\s-1IHM\s0 (Interface Homme Machine) en Perl/Tk.
.PP
En plus d'un e\*'dtieur/IDE, vous aurez sans doute besoin d'un shell plus
puissant en environnement Win32. Voici quelques possibilite\*'s :
.IP "Bash" 4
.IX Item "Bash"
fourni comme paquetage Cygwin ().
.IP "Ksh" 4
.IX Item "Ksh"
depuis la boite a\*` outils \s-1MKS\s0 (), ou le Bourne
shell de l'environnement U/WIN ()
.IP "Tcsh" 4
.IX Item "Tcsh"
, voir aussi
.IP "Zsh" 4
.IX Item "Zsh"
, voir aussi
.PP
\&\s-1MKS\s0 et U/WIN sont commerciaux (U/WIN est gratuit dans un cadre
e\*'ducation ou recherche) alors que Cygwin repose sur la licence
Publique \s-1GNU\s0 (mais c\*,a ne compte pas pour une utilisation aevc
Perl). Cygwin, \s-1MKS\s0 et U/WIN proposent chacun, en plus de leurs shells
respectifs, un ensemble complet d'outils standard Unix.
.PP
Si vous transfe\*'rez des fichiers textes entre Unix et Windows en
utilisant \s-1FTP\s0, assurez-vous de les faire en mode \s-1ASCII\s0 afin que les
caracte\*`res de fin de ligne soient correctement convertis.
.PP
Sur MacOS, l'application MacPerl propose un e\*'diteur de texte simple
limite\*' a\*` 32k qui peut se comporter comme un \s-1IDE\s0 rudimentaire. A\*`
l'oppose\*', l'outil \s-1MPW\s0 Perl peut utiliser le shell \s-1MPW\s0 lui\-me\*^me comme
un e\*'diteur (sans la limite des 32k).
.IP "Affrus" 4
.IX Item "Affrus"
est un ve\*'ritable environnement de de\*'veloppement en Perl avec un
de\*'bogueur complet ().
.IP "Alpha" 4
.IX Item "Alpha"
est un e\*'diteur e\*'crit et extensible en Tcl qui supporte de nombreux
langages de programmation ou a\*` base de balises tels que Perl et \s-1HTML\s0
().
.IP "BBEdit et BBEdit Lite" 4
.IX Item "BBEdit et BBEdit Lite"
sont des e\*'dtiteurs de texte pour Mac \s-1OS\s0 qui ont un mode reconnaissant
le Perl ().
.PP
Pepper et Pe sont des e\*'dtiteurs de texte ge\*'rant les langages de
programmation et de\*'veloppe\*'s respectivement pour Mac \s-1OS\s0 X et BeOS ().
.Sh "Ou\*` puis-je trouver des macros pour Perl sous vi\ ?"
.IX Subsection "Ou` puis-je trouver des macros pour Perl sous vi?"
Pour une version comple\*`te du fichier de configuration de Tom
Christiansen pour vi, voyez
,
il s'agit du fichier standard pour les e\*'mulateurs vi. Cela fonctionne
mieux avec nvi, la dernie\*`re version de vi de Berkeley, qui peut
e\*'ventuellement e\*^tre compile\*'e avec un interpre\*'teur Perl inclut \*(-- voir
.
.Sh "Ou\*` puis-je trouver le mode perl pour emacs\ ?"
.IX Subsection "Ou` puis-je trouver le mode perl pour emacs?"
Depuis la version 19 patchlevel 22 de Emacs, perl\-mode.el et l'aide
pour le de\*'bogueur Perl sont inclus. Vous devriez l'avoir dans la
distribution standard version 19 d'Emacs.
.PP
Dans le re\*'pertoire du code source de Perl, vous trouverez un
re\*'pertoire nomme\*' \*(L"emacs\*(R", qui contient un mode d'e\*'dition perl qui
colore les instructions Perl, fournit une aide contextuelle, et autres
choses sympathiques.
.PP
Notez que le mode perl de Emacs changera les lignes du genre
\&\f(CW"main\*(Aqfoo"\fR (apostrophe), et modifiera les tabulations et
surlignages. Vous utilisez probablement de toute fac\*,on \f(CW"main::foo"\fR
dans votre nouveau code Perl, donc ceci n'est pas bien grave.
.Sh "Comment utiliser des 'curses' avec Perl\ ?"
.IX Subsection "Comment utiliser des 'curses' avec Perl?"
Le module Curses du \s-1CPAN\s0 fournit une interface objet chargeable
dynamiquement pour la librairie \*(L"curses\*(R". Une petite de\*'mo se trouve
dans le re\*'pertoire
\ ; Ce
programme re\*'pe\*`te re\*'gulie\*`rement une commande et rafrai\*^chit l'e\*'cran
comme il faut, rendant ainsi \fBrep ps axu\fR similaire a\*` \fBtop\fR.
.Sh "Comment puis-je utiliser X ou Tk avec Perl\ ?"
.IX Subsection "Comment puis-je utiliser X ou Tk avec Perl?"
Les modules Tk forment une interface pour les outils Tk, entie\*`rement
oriente\*'e objet et base\*'e sur Perl qui vous e\*'vite d'utiliser Tcl pour
avoir acce\*`s a\*` Tk. Sx est une interface pour l'ensemble Athena
Widget. Les deux sont disponibles sur \s-1CPAN\s0. Voyez le re\*'pertoire
.
.PP
D'inestimables aides pour la programmation en Perl/Tk sont la \s-1FAQ\s0
Perl/Tk sur
, le guide
de re\*'fe\*'rence Perl/Tk disponible sur
et les pages de manuel
en ligne sur
.
.Sh "Comment rendre mes programmes Perl plus rapides\ ?"
.IX Subsection "Comment rendre mes programmes Perl plus rapides?"
La meilleure fac\*,on pour y parvenir est d'utiliser un meilleur
algorithme. Cela peut souvent faire une e\*'norme diffe\*'rence. Le livre de
Jon Bentley \fIProgramming Pearls\fR (sans faute de frappe !) donne aussi
de bonnes astuces d'optimisation. Quelques conseils pour
l'ame\*'lioration de la vitesse\ : utilisez benchmark pour e\*^tre
certain que vous optimisez la bonne partie de votre code, cherchez de
meilleurs algorithmes pluto\*^t que des micro-optimisations pour votre
code actuel, et si rien ne s'arrange, conside\*'rez qu'il vous faut juste
acheter un mate\*'riel plus rapide. Si vous ne l'avez pas de\*'ja\*` fait, vous
deviez probablement lire la re\*'ponse a\*` la question pose\*'e plus haut
\&\*(L"Comment mesurer les performances de mes programmes Perl\ ?\*(R".
.PP
Une approche diffe\*'rente est d'utiliser Autoload pour le code peu
utilise\*'. Voyez les modules AutoSplit et AutoLoader dans la
distribution standard pour ce faire. Vous pouvez aussi localiser le
goulot d'e\*'tranglement et penser a\*` e\*'crire cette partie en C, de la me\*^me
fac\*,on que nous avons l'habitude d'e\*'crire les parties lentes de C en
assembleur. Au lieu de re\*'e\*'crire en C, vous pouvez aussi utiliser des
modules ayant leurs sections critiques de\*'ja\*` e\*'crites en C (par exemple,
le module \s-1PDL\s0 du \s-1CPAN\s0).
.PP
Si vous liez votre exe\*'cutable perl a\*` une librairie partage\*'e
\&\fIlibc.so\fR, vous pouvez souvent gagner entre 10\ % et 25\ %
en performance en le liant pluto\*^t avec une librairie statique
libc.a. Cela fera un exe\*'cutable plus important, mais vos programmes
(et programmeurs) Perl vous en remercieront. Voyez le fichier
\&\fI\s-1INSTALL\s0\fR dans le code source de la distribution pour plus
d'informations.
.PP
Le programme undump e\*'tait une ancienne tentative visant a\*` ame\*'liorer la
vitesse des programmes Perl en les sauvegardant sous forme de\*'ja\*`
compile\*'e sur le disque. Ce n'est plus une option viable, puisque cela
ne fonctionnait que sur peu d'architectures, et que ce n'e\*'tait pas une
bonne solution de toute fac\*,on.
.Sh "Comment faire pour que mes programmes Perl occupent moins de me\*'moire\ ?"
.IX Subsection "Comment faire pour que mes programmes Perl occupent moins de me'moire?"
Quand Perl a des e\*'changes internes trop longs, il pre\*'fe\*`re imputer cela
a\*` un proble\*`me de me\*'moire. Les scalaires en Perl utilisent plus de
me\*'moire que les chai\*^nes de caracte\*`res en C, les tableaux en utilisent
plus aussi, et les tables de hachage moins. Bien qu'il y ait encore
beaucoup a\*` faire, les versions re\*'centes re\*'pondent a\*` ces proble\*`mes. Par
exemple, dans la version 5.004, les cle\*'s duplique\*'es des tables de
hachage sont partage\*'es par toutes les tables de hachage les utilisant,
ne ne\*'cessitant pas de re\*'\-allocation.
.PP
Dans certains cas, l'usage de \fIsubstr()\fR ou \fIvec()\fR pour simuler des
tableaux peut e\*^tre tre\*`s be\*'ne\*'fique. Par exemple, un tableau d'un
millier de boole\*'ens prendra au moins 20\ 000 octets, mais il peut
e\*^tre remplace\*' par un vecteur de 125 octets \*(-- re\*'alisant ainsi une
e\*'conomie conside\*'rable de me\*'moire. Le module standard Tie::SubstrHash
peut aussi aider pour certains types de structures de donne\*'es. Si vous
travaillez avec des structures de donne\*'es spe\*'cifiques (matrices, par
exemple), les modules qui les imple\*'mentent en C peuvent utiliser moins
de me\*'moire que leurs e\*'quivalents en Perl.
.PP
Autre chose, essayez de savoir si Perl a e\*'te\*' compile\*' avec le malloc
syste\*`me ou le malloc de Perl. Quel qu'il soit, essayez d'utiliser
l'autre, et voyez si cela fait une diffe\*'rence. Les informations sur
malloc se trouvent dans le fichier \fI\s-1INSTALL\s0\fR du source de la
distribution. Vous pouvez savoir quel malloc vous utilisez en tapant
\&\f(CW\*(C`perl \-V:usemymalloc\*(C'\fR.
.PP
E\*'videmment, le moeyn le plus su\*^r de re\*'duire l'occupation me\*'moire est
d'en utiliser le moins possible de\*`s le de\*'part. De bonnes pratiques de
programmation peuvent aider :
.IP "\(bu" 4
Ne faites pas de slurp !
.Sp
Ne lisez pas un fichier complet en me\*'moire si vous pouvez le traiter
ligne par ligne. Plus concre\*`tement, utilisez une boucle comme :
.Sp
.Vb 6
\& #
\& # Bonne ide\*'e
\& #
\& while () {
\& # ...
\& }
.Ve
.Sp
pluto\*^t que :
.Sp
.Vb 7
\& #
\& # Mauvaise ide\*'e
\& #
\& @data = ;
\& foreach (@data) {
\& # ...
\& }
.Ve
.Sp
Tant que les fichiers traite\*'s sont petits, cela n'a pas beaucoup
d'importance mais s'ils deviennent gros alors cela fera une e\*'norme
diffe\*'rence.
.IP "\(bu" 4
Utilisez map et grep intelligement
.Sp
Souvenez-vous que map et grep utilise un argument sous forme de \s-1LISTE\s0,
donc faire :
.Sp
.Vb 1
\& @wanted = grep {/pattern/} ;
.Ve
.Sp
chargera le fichier complet en me\*'moire. Pour de gros fichiers, il vaut
mieux utiliser une boucle :
.Sp
.Vb 3
\& while () {
\& push(@wanted, $_) if /pattern/;
\& }
.Ve
.IP "\(bu" 4
E\*'vitez les guillemets et les stringifications inutiles
.Sp
Ne placez de grande chai\*^nes de caracte\*`res entre guillemets si ce n'est
pas absolument ne\*'cessaire. Le code suivant :
.Sp
.Vb 1
\& my $copie = "$grande_chaine";
.Ve
.Sp
re\*'alise 2 copies de \f(CW$grande_chaine\fR (une pour \f(CW$copie\fR et une autre pour
les guillemets). Alors que :
.Sp
.Vb 1
\& my $copie = $grande_chaine;
.Ve
.Sp
ne fait qu'une seule copie.
.Sp
C'est la me\*^me chose pour la stringification (la transformation en
chai\*^ne) de gros tableaux :
.Sp
.Vb 4
\& {
\& local $, = "\en";
\& print @gros_tableau;
\& }
.Ve
.Sp
est plus efficace d'un point de vue occupation me\*'moire que :
.Sp
.Vb 1
\& print join "\en", @gros_tableau;
.Ve
.Sp
ou que :
.Sp
.Vb 4
\& {
\& local $" = "\en";
\& print "@gros_tableau";
\& }
.Ve
.IP "\(bu" 4
Utilisez les re\*'fe\*'rences
.Sp
Passez vos tableaux et tables de hachages par re\*'fe\*'rence pluto\*^t que par
valeur. De\*'ja\*`, c'est le seul moyen de passer plusieurs listes ou tables
de hachage (ou les deux) en un seul appel ou return. Cela e\*'vite aussi
une recopie de tout leur contenu. Par contre, il faut le faire avec
pre\*'caution car tout changement sera alors propage\*' aux donne\*'es
originales. Si vous avez re\*'ellement besoin de modifier une copie, vous
devrez sacrifier la me\*'moire ne\*'cessaire a\*` cette copie.
.IP "\(bu" 4
Lie\*'es les grosses variables avec le disque
.Sp
Pour de tre\*`s \*(L"grosses\*(R" structures de donne\*'es (celles dont la taille
de\*'passe la taille me\*'moire disponible), pensez a\*` utiliser l'un des
modules \s-1DB\s0 qui stocke l'information sur disque pluto\*^t qu'en
me\*'moire. Cela a e\*'videmment un impact sur le temps d'acce\*`s mais ce sera
tre\*`s probablement plus efficace que d'utiliser de fac\*,on massive le
swap me\*'moire sur le disque.
.Sh "Est-ce su\*^r de retourner un pointeur sur une donne\*'e locale\ ?"
.IX Subsection "Est-ce su^r de retourner un pointeur sur une donne'e locale?"
Oui. Le ramasse-miettes (le gestionnaire de me\*'moire) de Perl fait
attention a\*` cela.
.PP
.Vb 4
\& sub makeone {
\& my @a = ( 1 .. 10 );
\& return \e@a;
\& }
\&
\& for ( 1 .. 10 ) {
\& push @many, makeone();
\& }
\&
\& print $many[4][5], "\en";
\&
\& print "@many\en";
.Ve
.Sh "Comment puis-je libe\*'rer un tableau ou une table de hachage pour re\*'duire mon programme\ ?"
.IX Subsection "Comment puis-je libe'rer un tableau ou une table de hachage pour re'duire mon programme?"
(contribution de Michael Carman)
.PP
Vous ne pouvez pas. La me\*'moire alloue\*'e aux variables lexicales (c'est
a\*` dire les variables \fImy()\fR) ne peut pas e\*^tre re\*'utilise\*'e me\*^me si on sort
de sa porte\*'e (NdT: mais ce n'est heureusement pas le cas des donne\*'es
re\*'fe\*'rence\*'es par ces variables). Elle reste re\*'serve\*'e au cas ou\*` la
variable reviendrait a\*` nouveau a\*` porte\*'e. Le me\*'moire alloue\*'e aux
variables globales peut e\*^tre re\*'utilise\*'e (par votre programme) en leur
appliquant \fIundef()\fR ou \fIdelete()\fR.
.PP
Sur la plupart des syste\*`mes d'exploitation, la me\*'moire alloue\*'e a\*` un
programme ne peut pas e\*^tre retourne\*'e au syste\*`me. C'est pourquoi les
programmes ayant un temps d'exe\*'cution tre\*`s long se re\*'\-exe\*'cutent
eux\-me\*^me. Quelques syste\*`mes d'exploitation (notamment, les syste\*`mes
utilisant \fImmap\fR\|(2)) peuvent parfois re\*'cupe\*'rer certains espaces me\*'moires
qui ne sont plus utilise\*'s, mais, pour que cela fonctionne avec Perl,
il faut que perl soit configure\*' et compile\*' pour utiliser le malloc du
syste\*`me et non celui de perl.
.PP
En ge\*'ne\*'ral, vous n'avez pas a\*` (et vous ne devriez pas) vous pre\*'occuper
de l'allocation et de la de\*'sallocation de me\*'moire avec Perl.
.PP
Voir aussi \*(L"Comment faire pour que mes programmes Perl occupent moins
de me\*'moire\ ?\*(R".
.Sh "Comment rendre mes scripts \s-1CGI\s0 plus efficaces\ ?"
.IX Subsection "Comment rendre mes scripts CGI plus efficaces?"
Apre\*`s les mesures classiques de\*'crites pour rendre vos programmes Perl
plus rapides ou courts, il y a d'autres possibilite\*'s pour les
programmes \s-1CGI\s0. Il peut e\*^tre exe\*'cute\*' plusieurs fois par seconde.
E\*'tant donne\*' qu'a\*` chaque fois, il doit e\*^tre recompile\*', et demande un
me\*'gaoctet ou plus de me\*'moire alloue\*'e, cela peut couler le syste\*`me en
performances. Compiler en C \fBne vous avancera pas davantage\fR car le
de\*'marrage du processus est le point le plus lent.
.PP
Il y a 2 fac\*,ons classiques pour e\*'viter cette surcharge. Une solution
consiste a\*` exe\*'cuter le serveur \s-1HTTP\s0 Apache (disponible a\*`
) avec le module mod_perl ou mod_fastcgi.
.PP
Avec mod_perl et le module Apache::Registry (distribue\*' avec mod_perl),
httpd fonctionne avec un interpre\*'teur Perl inclus qui pre\*'compile votre
script puis l'exe\*'cute dans le me\*^me espace me\*'moire sans fork.
L'extension Apache donne aussi a\*` Perl l'acce\*`s a\*` la librairie \s-1API\s0 du
serveur, ce qui fait qu'un module e\*'crit en Perl peut faire quasiment
tout ce qu'un module en C peut. Pour en savoir plus sur mod_perl,
voyez .
.PP
Avec le module \s-1FCGI\s0 (du \s-1CPAN\s0) et le module mod_fastcgi (disponible sur
) chacun de vos programmes devient un processus
\&\s-1CGI\s0 de\*'mon permanent.
.PP
Chacune de ces 2 solutions peut avoir de grandes conse\*'quences sur
votre syste\*`me et sur votre fac\*,on d'e\*'crire vos programmes \s-1CGI\s0, donc
utilisez-les avec pre\*'caution.
.PP
Voir
.
.Sh "Comment dissimuler le code source de mon programme Perl\ ?"
.IX Subsection "Comment dissimuler le code source de mon programme Perl?"
Effacez-le.\ :\-) Plus se\*'rieusement, il y a bon nombre de
solutions (pour la plupart peu satisfaisante) avec diffe\*'rents degre\*'s
de \*(L"se\*'curite\*'\*(R".
.PP
Tout d'abord, en aucun cas, vous ne pouvez o\*^ter le droit de lecture du
script, car le code source doit pouvoir e\*^tre lu pour pouvoir e\*^tre
compile\*' et interpre\*'te\*'. (Ce qui ne signifie pas que le code source d'un
script \s-1CGI\s0 est accessible en lecture pour les visiteurs du site web \*(--
il l'est uniquement pour ceux qui ont acce\*`s au syste\*`me de
fichiers). Donc vous devez laisser ces permissions au niveau
socialement sympathique de 0755.
.PP
Certains voient cela comme un proble\*`me de se\*'curite\*'. Si votre
programme fait des actions mettant en cause la se\*'curite\*' du syste\*`me, et
repose sur la confiance aveugle que vous avez dans le fait que les
visiteurs ne savent pas comment exploiter ces trous de se\*'curite\*'s,
alors, votre programme n'est pas se\*'curise\*'. Il est souvent possible de
de\*'tecter ce genre de trous et de les exploiter sans jamais voir le
code source. La se\*'curite\*' qui repose sur l'obscurite\*', autrement dit qui
repose sur la non visibilite\*' des bugs (au lieu de les re\*'soudre) est
une se\*'curite\*' tre\*`s faible.
.PP
Vous pouvez essayer d'utiliser le cryptage du code via des filtres de
source (depuis la version 5.8 les modules Filter::Simple et
Filter::Util::Call sont inclus dans la distribution standard), mais
n'importe quel programmeur se\*'rieux pourra les de\*'crypter. Vous pouvez
essayer d'utiliser le compilateur et interpre\*'teur en binaire de\*'crit
ci-dessous, mais les plus curieux pourront encore le de\*'compiler. Vous
pouvez essayer le compilateur en code natif de\*'crit ci-dessous, mais
des crackers peuvent encore le de\*'sassembler. Cela pose diffe\*'rents
degre\*'s de difficulte\*'s aux personnes qui en veulent a\*` votre code, mais
c\*,a ne les empe\*^chera pas de le retrouver (c'est vrai pour n'importe
quel langage, pas juste pour Perl).
.PP
Il est tre\*`s facile de re\*'cupe\*'rer les sources d'un programme Perl. Il
vous suffit de fournir ce programme a\*` l'interpre\*'teur perl et
d'utiliser les modules de la hie\*'rarchie B::*. Le module B::Deparse,
par exemple, fait e\*'chouer la plupart des tentatives de dissumulation
de code. Encore une fois, cela n'a rien de spe\*'cifique a\*` Perl.
.PP
Si cela vous ennuie que des personnes puissent profiter de votre code,
alors la premie\*`re chose a\*` faire est d'indiquer une licence restrictive
au de\*'but de votre code, ce qui vous donne une se\*'curite\*' le\*'gale. Mettez
une licence a\*` votre programme et saupoudrez-le de menaces diverses
telle que \*(L"Ceci est un programme prive\*' non distribue\*', de la socie\*'te\*'
\&\s-1XYZ\s0. Votre acce\*`s a\*` ce code source ne vous donne pas le droit de
l'utiliser bla bla bla.\*(R" Nous ne sommes pas juristes, bien su\*^r, donc
vous devriez en consulter un pour vous assurer que votre texte de
licence tient devant un tribunal.
.Sh "Comment compiler mon programme Perl en code binaire ou C\ ?"
.IX Subsection "Comment compiler mon programme Perl en code binaire ou C?"
(contribution de brian d foy)
.PP
De manie\*`re ge\*'ne\*'rale, ce n'est pas possible. Il existe dans certains
cas des solutions. Les gens demandent souvent cela parce qu'ils
veulent distribuer leur travail sans donner le code source. Vous ne
verrez sans doute aucune ame\*'lioration des performances puisque la
plupart des solutions ne font qu'inte\*'grer un interpre\*'teur Perl au
produit final (mais voyez tout de me\*^me \*(L"Comment rendre mes programmes
Perl plus rapides\ ?\*(R").
.PP
Le Perl Archive Tooolkit () est a\*` Perl
ce que \s-1JAR\s0 est a\*` Java. Il est disponible sur \s-1CPAN\s0 ().
.PP
La hie\*'rarchie B::*, parfois appele\*'e \*(L"le compilateur Perl\*(R", est en fait
un moyen pour les programmes Perl d'acce\*'der a\*` leurs propres entrailles
pluto\*^t qu'un moyen de cre\*'er des versions pre\*'\-compile\*'es. Mais il est
vrai que le module B::Bytecode peut transformer votre script en un
code binaire que vous pouvez ensuite recharger via le module
ByteLoader pour l'exe\*'cuter comme un script Perl normal.
.PP
Il existe quelques produits commerciaux qui font le travail pour vous
si vous achetez la licence correspondante.
.PP
Le Perl Dev Kit ()
d'ActiveState peut \*(L"transformer votre programme Perl en un fichier
directement exe\*'cutable sur HP-UX, Linux, Solaris et Windows.\*(R"
.PP
Perl2Exe () est un programme
en ligne de commande qui converit les scripts perl en exe\*'cutables. Il
existe aussi bien pour Windows que pour les plateformes unix.
.Sh "Comment compiler Perl pour en faire du Java\ ?"
.IX Subsection "Comment compiler Perl pour en faire du Java?"
Vous pouvez inte\*'grer Java et Perl avec le Perl Resource Kit d'O'Reilly
Media. Voir .
.PP
Perl 5.6 vient avec Java Perl Lingo (ou \s-1JPL\s0). \s-1JPL\s0, qui est encore en
de\*'veloppement, permet d'appeler du code Perl depuis Java. Lire le
fichier jpl/README dans l'arborescence des sources Perl.
.ie n .Sh "Comment faire fonctionner ""#!perl"" sur [\s-1MS\-DOS\s0,NT,...]\ ?"
.el .Sh "Comment faire fonctionner \f(CW#!perl\fP sur [\s-1MS\-DOS\s0,NT,...]\ ?"
.IX Subsection "Comment faire fonctionner #!perl sur [MS-DOS,NT,...]?"
Pour \s-1OS/2\s0 utilisez juste
.PP
.Vb 1
\& extproc perl \-S \-your_switches
.Ve
.PP
comme premie\*`re ligne dans le fichier \f(CW\*(C`*.cmd\*(C'\fR (\f(CW\*(C`\-S\*(C'\fR est du\*^ a\*` un bug
dans la gestion de \*(L"extproc\*(R" par cmd.exe). Pour \s-1DOS\s0, il faudrait
d'abord que quelqu'un cre\*'er un fichier batch similaire puis le codifie
dans \f(CW\*(C`ALTERNATIVE_SHEBANG\*(C'\fR (voir le fichier \fI\s-1INSTALL\s0\fR dans la
distribution pour plus d'informations).
.PP
L'installation sur Win95/98/NT, avec le portage Perl de ActiveState,
va modifier la table de registre pour associer l'extension \f(CW\*(C`.pl\*(C'\fR avec
l'interpre\*'teur perl. Si vous utilisez un autre portage, peut\-e\*^tre
me\*^me en compilant votre propre Perl Win95/98/NT a\*` l'aide d'une version
Windows de gcc (e.g. avec cygwin ou mingw32), alors vous devrez
modifier la base de registres vous\-me\*^me. En plus d'associer \f(CW\*(C`.pl\*(C'\fR
avec l'interpre\*'teur, les gens sous \s-1NT\s0 peuvent utiliser \f(CW\*(C`SET
PATHEXT=%PATHEXT%;.PL\*(C'\fR pour qu'ils puissent exe\*'cuter le programme
\&\f(CW\*(C`install\-linux.pl\*(C'\fR en tapant simplement \f(CW\*(C`install\-linux\*(C'\fR.
.PP
Sous \*(L"Classic\*(R" ou MacOS, les programmes Perl auront les attributs
Cre\*'ateur et Type approprie\*'s, un double-clic dessus appellera donc
l'application Perl. Sous Mac \s-1OS\s0 X, les scripts utilisant une ligne
\&\f(CW\*(C`#!...\*(C'\fR peuvent e\*^tre transforme\*'s en vraies applications via
l'utilitaire DropScript de Wil Sanchez ().
.PP
\&\fI\s-1IMPORTANT\s0!\fR\ : Quoi que vous fassiez, \s-1SURTOUT\s0 ne vous contentez pas
seulement d'installer votre interpre\*'teur dans votre re\*'pertoire
cgi-bin, pour faire fonctionner votre serveur web avec vos programmes.
C'est un E\*'\s-1NORME\s0 risque de se\*'curite\*'. Prenez le temps de bien ve\*'rifier
que tout fonctionne correctement.
.Sh "Puis-je e\*'crire des programmes Perl pratiques sur la ligne de commandes\ ?"
.IX Subsection "Puis-je e'crire des programmes Perl pratiques sur la ligne de commandes?"
Oui. Lisez perlrun pour plus d'informations. Voici quelques
exemples. (on conside\*`re ici un shell Unix avec les re\*`gles standard
d'apostrophes.)
.PP
.Vb 2
\& # Additionner le premier et lz dernier champs
\& perl \-lane \*(Aqprint $F[0] + $F[\-1]\*(Aq *
\&
\& # Identifier des fichiers\-textes
\& perl \-le \*(Aqfor(@ARGV) {print if \-f && \-T _}\*(Aq *
\&
\& # enlever la plupart des commentaires d\*(Aqun programme C
\& perl \-0777 \-pe \*(Aqs{/\e*.*?\e*/}{}gs\*(Aq foo.c
\&
\& # Rajeunir un fichier d\*(Aqun mois
\& perl \-e \*(Aq$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)\*(Aq *
\&
\& # Trouver le premier uid non utilise\*'
\& perl \-le \*(Aq$i++ while getpwuid($i); print $i\*(Aq
\&
\& # Afficher des chemins raisonnables vers des re\*'pertoires man
\& echo $PATH | perl \-nl \-072 \-e \*(Aq
\& s![^/+]*$!man!&&\-d&&!$s{$_}++&&push@m,$_;END{print"@m"}\*(Aq
.Ve
.PP
\&\s-1OK\s0, le dernier n'est pas tre\*`s simple.\ :\-)
.Sh "Pourquoi les commandes Perl a\*` une ligne ne fonctionnent-elles pas sur mon DOS/Mac/VMS\ ?"
.IX Subsection "Pourquoi les commandes Perl a` une ligne ne fonctionnent-elles pas sur mon DOS/Mac/VMS?"
Le proble\*`me est ge\*'ne\*'ralement que les interpre\*'teurs de commandes sur
ces syste\*`mes ont des points de vue diffe\*'rents sur les apostrophes,
guillemets, etc, par rapport aux shell Unix sous lesquels a e\*'te\*' cre\*'e\*'e
cette possibilite\*' de commande a\*` une ligne. Sur certains syste\*`mes, vous
devrez changer les apostrophes en guillemets, ce que vous ne devez
\&\fI\s-1PAS\s0\fR faire sur Unix ou sur des syste\*`mes Plan9. Vous devrez aussi
probablement changer un simple % en %%.
.PP
Par exemple\ :
.PP
.Vb 2
\& # Unix
\& perl \-e \*(Aqprint "Hello world\en"\*(Aq
\&
\& # DOS, etc.
\& perl \-e "print \e"Hello world\en\e""
\&
\& # Mac
\& print "Hello world\en"
\& (then Run "Myscript" or Shift\-Command\-R)
\&
\& # MPW
\& perl \-e \*(Aqprint "Hello world\en"\*(Aq
\&
\& # VMS
\& perl \-e "print ""Hello world\en"""
.Ve
.PP
Le proble\*`me est que rien de tout cela n'est garanti\ : cela
de\*'pend de l'interpre\*'teur de commande. Sous Unix, les deux premiers
exemples marchent presque toujours. Sous \s-1DOS\s0 il est bien possible
qu'aucun d'entre eux ne fonctionne. Si 4DOS est l'interpre\*'teur de
commandes, vous aurez probablement plus de chances avec ceci\ :
.PP
.Vb 1
\& perl \-e "print "Hello world\en""
.Ve
.PP
Sous Mac, cela de\*'pend de l'environnement que vous utilisez. Le shell
MacPerl ou \s-1MPW\s0, ressemble pluto\*^t aux shells Unix car il accepte pas
mal de variantes dans les apostrophes, guillemets, etc, excepte\*' qu'il
utilise librement les caracte\*`res de contro\*^le Mac non \s-1ASCII\s0 comme des
caracte\*`res normaux.
.PP
L'usage de \fIqq()\fR, q() et \fIqx()\fR, a\*` la place de \*(L"guillemets\*(R",
d''apostrophes' et d'`accents graves` peut rendre les programmes sur
une ligne plus faciles a\*` e\*'crire.
.PP
Il n'y a pas de solution globale a\*` tout cela. Il y a un manque.
.PP
[Kenneth Albanowski a contribue\*' a\*` certaines de ces re\*'ponses.]
.Sh "Ou\*` puis-je en apprendre plus sur la programmation \s-1CGI\s0 et Web en Perl\ ?"
.IX Subsection "Ou` puis-je en apprendre plus sur la programmation CGI et Web en Perl?"
Pour les modules, prenez les modules \s-1CGI\s0 ou \s-1LWP\s0 au \s-1CPAN\s0. Pour les
bouquins, voyez les deux tout spe\*'cialement de\*'die\*'s au de\*'veloppement
pour le web, dans la question sur les livres. Pour des proble\*`mes ou
questions du style \*(L"Pourquoi ai-je une erreur 500\*(R" ou \*(L"Pourquoi cela
ne fonctionne-t-il pas bien par le navigateur alors que tout marche
depuis la ligne de commande shell\*(R", lisez ou la MetaFAQ CGIs\ :
.PP
.Vb 1
\& http://www.perl.org/CGI_MetaFAQ.html
.Ve
.Sh "Ou\*` puis-je apprendre la programmation oriente\*'e objet en Perl\ ?"
.IX Subsection "Ou` puis-je apprendre la programmation oriente'e objet en Perl?"
Un bon point de de\*'part est perltoot puis ensuite vous pouvez
utiliser perlobj, perlboot, perltooc et perlbot comme
re\*'fe\*'rences.
.PP
Deux bons livres sur la programmation oriente\*'e objet en Perl sont
\&\*(L"Object-Oriented Perl\*(R" de Damian Conway chez Manning et "\*(L"Learning
Perl ! References, Objects, & Modules\*(R" par Randal Schwartz et Tom
Phoenix chez O'Reilly Media.
.Sh "Ou\*` puis-je en apprendre plus sur l'utilisation lie\*'e de Perl et de C\ ?"
.IX Subsection "Ou` puis-je en apprendre plus sur l'utilisation lie'e de Perl et de C?"
Si vous voulez appeler du C a\*` partir du Perl, commencez avec
perlxstut, puis perlxs, xsubpp, et perlguts. Si vous
voulez appeler du Perl a\*` partir du C, alors lisez perlembed,
perlcall, et perlguts. N'oubliez pas que vous pouvez apprendre
beaucoup en regardant comment des auteurs de modules d'extension ont
e\*'crit leur code et re\*'solu leurs proble\*`mes.
.PP
Vous n'avez peut\-e\*^tre pas besoin de toute la puissance de \s-1XS\s0. Le
module Inline::C vous permet de placer du code C directement dans
votre script Perl. Il ge\*`re lui\-me\*^me toute la magie ne\*'cessaire au bon
fonctionnement. Vous devez encore connai\*^tre un minimum de choses sur
l'\s-1API\s0 Perl mais vous n'avez plus a\*` ge\*'rer toute la complexite\*' des
fichiers \s-1XS\s0.
.Sh "J'ai lu perlembed, perlguts, etc., mais je ne peux inclure du perl dans mon programme C, qu'est ce qui ne va pas\ ?"
.IX Subsection "J'ai lu perlembed, perlguts, etc., mais je ne peux inclure du perl dans mon programme C, qu'est ce qui ne va pas?"
Te\*'le\*'chargez le kit ExtUtils::Embed depuis \s-1CPAN\s0 et exe\*'cutez 'make
test'. Si le test est bon, lisez les pods encore et encore et encore.
Si le test e\*'choue, voyez perlbug et envoyez un rapport de bug avec
les sorties e\*'cran de \f(CW\*(C`make test TEST_VERBOSE=1\*(C'\fR ainsi que de \f(CW\*(C`perl
\&\-V\*(C'\fR.
.Sh "Quand j'ai tente\*' d'exe\*'cuter mes scripts, j'ai eu ce message. Qu'est ce que cela signifie\ ?"
.IX Subsection "Quand j'ai tente' d'exe'cuter mes scripts, j'ai eu ce message. Qu'est ce que cela signifie?"
Une liste comple\*`te des messages d'erreur et des avertissements de Perl
accompagne\*'s d'un texte explicatif se trouve dans perldiag. Vous
pouvez aussi utiliser le programme splain (distribue\*' avec perl) pour
expliquer les messages d'erreur\ :
.PP
.Vb 2
\& perl program 2>diag.out
\& splain [\-v] [\-p] diag.out
.Ve
.PP
ou modifiez votre programme pour qu'il vous explique les messages\ :
.PP
.Vb 1
\& use diagnostics;
.Ve
.PP
ou
.PP
.Vb 1
\& use diagnostics \-verbose;
.Ve
.Sh "Qu'est-ce que MakeMaker\ ?"
.IX Subsection "Qu'est-ce que MakeMaker?"
Ce module (qui fait partie de la distribution standard de Perl) est
fait pour e\*'crire un Makefile pour un module d'extension a\*` partir d'un
Makefile.PL. Pour plus d'informations, voyez ExtUtils::MakeMaker.
.SH "AUTEUR ET COPYRIGHT"
.IX Header "AUTEUR ET COPYRIGHT"
Copyright (c) 1997\-1999 Tom Christiansen et Nathan Torkington. Tous
droits re\*'serve\*'s.
.PP
Cette documentation est libre ; vous pouvez la redistribuer ou la
modifier sous les me\*^mes conditions que Perl lui\-me\*^me.
.PP
Inde\*'pendante de cette distribution, tous les codes d'exemple ici, sont
du domaine public. Vous e\*^tes autorise\*' et encourage\*' a\*` les utiliser tels
quels ou de fac\*,on de\*'rive\*'e dans vos propres programmes, pour le fun ou
pour le profit, comme vous le voulez. Un simple commentaire signalant
les auteurs serait bien courtois, mais n'est pas obligatoire.
.SH "TRADUCTION"
.IX Header "TRADUCTION"
.Sh "Version"
.IX Subsection "Version"
Cette traduction franc\*,aise correspond a\*` la version anglaise distribue\*'e avec
perl 5.8.8. Pour en savoir plus concernant ces traductions, consultez
.
.Sh "Traducteur"
.IX Subsection "Traducteur"
Se\*'bastien Joncheray . Mise a\*` jour : Paul Gaborit
.
.Sh "Relecture"
.IX Subsection "Relecture"
Pascal Ethvignot ,
Roland Trique ,
Ge\*'rard Delafond.