Provided by: manpages-zh_1.5.2-1_all bug

NAME

       perlfaq3 -  (2003/11/24 19:55:50)

DESCRIPTION


        ()?

        CPAN perlfaq2? (man pages)?:

               Basics          perldata, perlvar, perlsyn, perlop, perlsub
               Execution       perlrun, perldebug
               Functions       perlfunc
               Objects         perlref, perlmod, perlobj, perltie
               Data Structures perlref, perllol, perldsc
               Modules         perlmod, perlmodlib, perlsub
               Regexes         perlre, perlfunc, perlop, perllocale
               Moving to perl5 perltrap, perl
               Linking w/C     perlxstut, perlxs, perlcall, perlguts, perlembed
               Various         http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz
                               (
                                 Perl )

       perltoc perl

        Perl?

        perldebug(1) Perl

           perl -de 42

        Perl (symbol table) (stack backtraces) (set breakpoints)  (symbolic
       debuggers)

        Perl shell?

       The psh (Perl sh) is currently at version 1.8. The Perl Shell is a
       shell that combines the interactive nature of a Unix shell with the
       power of Perl. The goal is a full featured shell that behaves as
       expected for normal shell activity and uses Perl syntax and
       functionality for control-flow statements and other things.  You can
       get psh at http://www.focusresearch.com/gregor/psh/ .

       Zoidberg is a similar project and provides a shell written in perl,
       configured in perl and operated in perl. It is intended as a login
       shell and development environment. It can be found at
       http://zoidberg.sf.net/ or your local CPAN mirror.

       The Shell.pm module (distributed with Perl) makes Perl try commands
       which aren't part of the Perl language as shell commands.  perlsh from
       the source distribution is simplistic and uninteresting, but may still
       be what you want.

       You can use the ExtUtils::Installed module to show all installed
       distributions, although it can take awhile to do its magic.  The
       standard library which comes with Perl just shows up as "Perl"
       (although you can get those with Module::CoreList).

               use ExtUtils::Installed;

               my $inst    = ExtUtils::Installed->new();
               my @modules = $inst->modules();

       If you want a list of all of the Perl module filenames, you can use
       File::Find::Rule.

               use File::Find::Rule;

               my @files = File::Find::Rule->file()->name( '*.pm' )->in( @INC );

       If you do not have that module, you can do the same thing with
       File::Find which is part of the standard library.

           use File::Find;
           my @files;

           find sub { push @files, $File::Find::name if -f _ && /\.pm$/ },
                @INC;

               print join "\n", @files;

       If you simply need to quickly check to see if a module is available,
       you can check for its documentation.  If you can read the documentation
       the module is most likely installed.  If you cannot read the
       documentation, the module might not have any (in rare cases).

               prompt% perldoc Module::Name

       You can also try to include the module in a one-liner to see if perl
       finds it.

               perl -MModule::Name -e1

        Perl ?

        "use warnings"  "-w"

        "use strict" It prevents you from using symbolic references, makes you
       predeclare any subroutines that you call as bare words, and (probably
       most importantly) forces you to predeclare your variables with "my",
       "our", or "use vars".

       Did you check the return values of each and every system call?  The
       operating system (and thus Perl) tells you whether they worked, and if
       not why.

         open(FH, "> /etc/cantwrite")
           or die "Couldn't write to /etc/cantwrite: $!\n";

       Did you read perltrap?  It's full of gotchas for old and new Perl
       programmers and even has sections for those of you who are upgrading
       from languages like awk and C.

       Have you tried the Perl debugger, described in perldebug?  You can step
       through your program and see what it's doing and thus work out why what
       it's doing isn't what it should be doing.

        (profile)  perl ?

        CPAN Devel::DProf  perl  Benchmark.pm Benchmark.pm Devel::DProf

       Here's a sample use of Benchmark:

         use Benchmark;

         @junk = `cat /etc/motd`;
         $count = 10_000;

         timethese($count, {
                   'map' => sub { my @a = @junk;
                                  map { s/a/b/ } @a;
                                  return @a },
                   'for' => sub { my @a = @junk;
                                  for (@a) { s/a/b/ };
                                  return @a },
                  });

       This is what it prints (on one machine--your results will be dependent
       on your hardware, operating system, and the load on your machine):

         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)

       Be aware that a good benchmark is very hard to write.  It only tests
       the data you give it and proves little about the differing complexities
       of contrasting algorithms.

        Perl

       B::Xref  Perl cross-reference

           perl -MO=Xref[,OPTIONS] scriptname.plx

        Perl?

       Perltidy is a Perl script which indents and reformats Perl scripts to
       make them easier to read by trying to follow the rules of the
       perlstyle. If you write Perl scripts, or spend much time reading them,
       you will probably find it useful.  It is available at
       http://perltidy.sourceforge.net

       Of course, if you simply follow the guidelines in perlstyle, you
       shouldn't need to reformat.  The habit of formatting your code as you
       write it will help prevent bugs.  Your editor can and should help you
       with this.  The perl-mode or newer cperl-mode for emacs can provide
       remarkable amounts of help with most (but not all) code, and even less
       programmable editors can provide significant assistance.  Tom
       Christiansen and many other VI users  swear by the following settings
       in vi and its clones:

           set ai sw=4
           map! ^O {^M}^[O^T

       Put that in your .exrc file (replacing the caret characters with
       control characters) and away you go.  In insert mode, ^T is for
       indenting, ^D is for undenting, and ^O is for blockdenting-- as it
       were.  A more complete example, with comments, can be found at
       http://www.cpan.org/authors/id/TOMC/scripts/toms.exrc.gz

       The a2ps http://www-inf.enst.fr/%7Edemaille/a2ps/black+white.ps.gz does
       lots of things related to generating nicely printed output of
       documents, as does enscript at http://people.ssh.fi/mtr/genscript/ .

        Perl ctags ?

       Recent versions of ctags do much more than older versions did.
       EXUBERANT CTAGS is available from http://ctags.sourceforge.net/ and
       does a good job of making tags files for perl code.

       There is also a simple one at
       http://www.cpan.org/authors/id/TOMC/scripts/ptags.gz which may do the
       trick.  It can be easy to hack this into what you want.

       Is there an IDE or Windows Perl Editor?

       Perl programs are just plain text, so any editor will do.

       If you're on Unix, you already have an IDE--Unix itself.  The UNIX
       philosophy is the philosophy of several small tools that each do one
       thing and do it well.  It's like a carpenter's toolbox.

       If you want an IDE, check the following:

       Komodo
           ActiveState's cross-platform (as of April 2001 Windows and Linux),
           multi-language IDE has Perl support, including a regular expression
           debugger and remote debugging (
           http://www.ActiveState.com/Products/Komodo/index.html ).  (Visual
           Perl, a Visual Studio.NET plug-in is currently (early 2001) in beta
           ( http://www.ActiveState.com/Products/VisualPerl/index.html )).

       The Object System
           ( http://www.castlelink.co.uk/object_system/ ) is a Perl web
           applications development IDE, apparently for any platform that runs
           Perl.

       Open Perl IDE
           ( http://open-perl-ide.sourceforge.net/ ) Open Perl IDE is an
           integrated development environment for writing and debugging Perl
           scripts with ActiveState's ActivePerl distribution under Windows
           95/98/NT/2000.

       PerlBuilder
           ( http://www.solutionsoft.com/perl.htm ) is an integrated
           development environment for Windows that supports Perl development.

       visiPerl+
           ( http://helpconsulting.net/visiperl/ ) From Help Consulting, for
           Windows.

       OptiPerl
           ( http://www.optiperl.com/ ) is a Windows IDE with simulated CGI
           environment, including debugger and syntax highlighting editor.

       For editors: if you're on Unix you probably have vi or a vi clone
       already, and possibly an emacs too, so you may not need to download
       anything.  In any emacs the cperl-mode (M-x cperl-mode) gives you
       perhaps the best available Perl editing mode in any editor.

       If you are using Windows, you can use any editor that lets you work
       with plain text, such as NotePad or WordPad.  Word processors, such as
       Microsoft Word or WordPerfect, typically do not work since they insert
       all sorts of behind-the-scenes information, although some allow you to
       save files as "Text Only". You can also download text editors designed
       specifically for programming, such as Textpad ( http://www.textpad.com/
       ) and UltraEdit ( http://www.ultraedit.com/ ), among others.

       If you are using MacOS, the same concerns apply.  MacPerl (for Classic
       environments) comes with a simple editor.  Popular external editors are
       BBEdit ( http://www.bbedit.com/ ) or Alpha (
       http://www.kelehers.org/alpha/ ). MacOS X users can use Unix editors as
       well.

       GNU Emacs
           http://www.gnu.org/software/emacs/windows/ntemacs.html

       MicroEMACS
           http://www.microemacs.de/

       XEmacs
           http://www.xemacs.org/Download/index.html

       Jed http://space.mit.edu/~davis/jed/

       or a vi clone such as

       Elvis
           ftp://ftp.cs.pdx.edu/pub/elvis/ http://www.fh-wedel.de/elvis/

       Vile
           http://dickey.his.com/vile/vile.html

       Vim http://www.vim.org/

       For vi lovers in general, Windows or elsewhere:

               http://www.thomer.com/thomer/vi/vi.html

       nvi ( http://www.bostic.com/vi/ , available from CPAN in src/misc/) is
       yet another vi clone, unfortunately not available for Windows, but in
       UNIX platforms you might be interested in trying it out, firstly
       because strictly speaking it is not a vi clone, it is the real vi, or
       the new incarnation of it, and secondly because you can embed Perl
       inside it to use Perl as the scripting language.  nvi is not alone in
       this, though: at least also vim and vile offer an embedded Perl.

       The following are Win32 multilanguage editor/IDESs that support Perl:

       Codewright
           http://www.starbase.com/

       MultiEdit
           http://www.MultiEdit.com/

       SlickEdit
           http://www.slickedit.com/

       There is also a toyedit Text widget based editor written in Perl that
       is distributed with the Tk module on CPAN.  The ptkdb (
       http://world.std.com/~aep/ptkdb/ ) is a Perl/tk based debugger that
       acts as a development environment of sorts.  Perl Composer (
       http://perlcomposer.sourceforge.net/ ) is an IDE for Perl/Tk GUI
       creation.

       In addition to an editor/IDE you might be interested in a more powerful
       shell environment for Win32.  Your options include

       Bash
           from the Cygwin package ( http://sources.redhat.com/cygwin/ )

       Ksh from the MKS Toolkit ( http://www.mks.com/ ), or the Bourne shell
           of the U/WIN environment (
           http://www.research.att.com/sw/tools/uwin/ )

       Tcsh
           ftp://ftp.astron.com/pub/tcsh/ , see also
           http://www.primate.wisc.edu/software/csh-tcsh-book/

       Zsh ftp://ftp.blarg.net/users/amol/zsh/ , see also http://www.zsh.org/

       MKS and U/WIN are commercial (U/WIN is free for educational and
       research purposes), Cygwin is covered by the GNU Public License (but
       that shouldn't matter for Perl use).  The Cygwin, MKS, and U/WIN all
       contain (in addition to the shells) a comprehensive set of standard
       UNIX toolkit utilities.

       If you're transferring text files between Unix and Windows using FTP be
       sure to transfer them in ASCII mode so the ends of lines are
       appropriately converted.

       On Mac OS the MacPerl Application comes with a simple 32k text editor
       that behaves like a rudimentary IDE.  In contrast to the MacPerl
       Application the MPW Perl tool can make use of the MPW Shell itself as
       an editor (with no 32k limit).

       BBEdit and BBEdit Lite
           are text editors for Mac OS that have a Perl sensitivity mode (
           http://web.barebones.com/ ).

       Alpha
           is an editor, written and extensible in Tcl, that nonetheless has
           built in support for several popular markup and programming
           languages including Perl and HTML ( http://alpha.olm.net/ ).

       Pepper and Pe are programming language sensitive text editors for Mac
       OS X and BeOS respectively ( http://www.hekkelman.com/ ).

        vi  Perl

       For a complete version of Tom Christiansen's vi configuration file, see
       http://www.cpan.org/authors/Tom_Christiansen/scripts/toms.exrc.gz , the
       standard benchmark file for vi emulators.  The file runs best with nvi,
       the current version of vi out of Berkeley, which incidentally can be
       built with an embedded Perl interpreter--see
       http://www.cpan.org/src/misc/ .

        emacs perl?

        Emacs 19.22 (version 19 patchlevel 22) perl-mode.el perl  Emacs 19

        perl ``emacs''  cperl-mode

       ``main'foo'' emacs perl-mode   (indentation)  (hilighting)
       ``main::foo''  main'foo  package [perl5] main::foo

        Perl curses?

       The Curses module from CPAN provides a dynamically loadable object
       module interface to a curses library.  A small demo can be found at the
       directory http://www.cpan.org/authors/Tom_Christiansen/scripts/rep.gz ;
       this program repeats a command and updates the screen as needed,
       rendering rep ps axu similar to top.

       X Tk Perl?

       Tk  Perl  Tcl TkSx Athena Widget set CPAN
       http://www.cpan.org/modules/by-category/08_User_Interfaces/

       Invaluable for Perl/Tk programming are the Perl/Tk FAQ at
       http://w4.lns.cornell.edu/%7Epvhp/ptk/ptkTOC.html , the Perl/Tk
       Reference Guide available at
       http://www.cpan.org/authors/Stephen_O_Lidie/ , and the online manpages
       at http://www-users.cs.umn.edu/%7Eamundson/perl/perltk/toc.html .

        CGI Tk ?

       http://www.cpan.org/authors/id/SKUNZ/perlmenu.v4.0.tar.gz  curses

        Perl?

        (algorithm)Jon Bentley's book Programming Pearls (!)  Advice on
       benchmarking boils down to: benchmark and profile to make sure you're
       optimizing the right part, look for better algorithms instead of
       microtuning your code, and when all else fails consider just buying
       faster hardware.  You will probably want to read the answer to the
       earlier question ``How do I profile my Perl programs?'' if you haven't
       done so already.

        Perl  perl  AutoSplit AutoLoader C C C  ( CPAN PDL )

        perl libc.so libc.a perl 10-25% perl Perl ()  perl INSTALL

        undump

        Perl

        Perl  Perl (Scalar)  C  (Hashes) 5.004   (duplicate hash keys)

        substr() vec()  20,000 125 (bit vector) Tie::SubstrHash () C Perl

        Perl malloc  Perl malloc  malloc perl INSTALL  "perl -V:usemymalloc".
       perl malloc

       Of course, the best way to save memory is to not do anything to waste
       it in the first place. Good programming practices can go a long way
       toward this:

       * Don't slurp!
           Don't read an entire file into memory if you can process it line by
           line. Or more concretely, use a loop like this:

                   #
                   # Good Idea
                   #
                   while (<FILE>) {
                      # ...
                   }

           instead of this:

                   #
                   # Bad Idea
                   #
                   @data = <FILE>;
                   foreach (@data) {
                       # ...
                   }

           When the files you're processing are small, it doesn't much matter
           which way you do it, but it makes a huge difference when they start
           getting larger.

       * Use map and grep selectively
           Remember that both map and grep expect a LIST argument, so doing
           this:

                   @wanted = grep {/pattern/} <FILE>;

           will cause the entire file to be slurped. For large files, it's
           better to loop:

                   while (<FILE>) {
                           push(@wanted, $_) if /pattern/;
                   }

       * Avoid unnecessary quotes and stringification
           Don't quote large strings unless absolutely necessary:

                   my $copy = "$large_string";

           makes 2 copies of $large_string (one for $copy and another for the
           quotes), whereas

                   my $copy = $large_string;

           only makes one copy.

           Ditto for stringifying large arrays:

                   {
                           local $, = "\n";
                           print @big_array;
                   }

           is much more memory-efficient than either

                   print join "\n", @big_array;

           or

                   {
                           local $" = "\n";
                           print "@big_array";
                   }

       * Pass by reference
           Pass arrays and hashes by reference, not by value. For one thing,
           it's the only way to pass multiple lists or hashes (or both) in a
           single call/return. It also avoids creating a copy of all the
           contents. This requires some judgment, however, because any changes
           will be propagated back to the original data. If you really want to
           mangle (er, modify) a copy, you'll have to sacrifice the memory
           needed to make one.

       * Tie large variables to disk.
           For "big" data stores (i.e. ones that exceed available memory)
           consider using one of the DB modules to store it on disk instead of
           in RAM. This will incur a penalty in access time, but that's
           probably better than causing your hard disk to thrash due to
           massive swapping.

       ?

       Perl (garbage collection)

           sub makeone {
               my @a = ( 1 .. 10 );
               return \@a;
           }

           for ( 1 .. 10 ) {
               push @many, makeone();
           }

           print $many[4][5], "\n";

           print "@many\n";

       ?

        (re-exec) Some operating systems (notably, systems that use mmap(2)
       for allocating large chunks of memory) can reclaim memory that is no
       longer used, but on such systems, perl must be configured and compiled
       to use the OS's malloc, not perl's.

        my() Perl  (my() 10%) undef()  delete() Perl

        CGI (script)?

        Perl CGI  1 MB C   (start-up overhead)

        mod_perl  mod_fastcgi Apache HTTP server

        mod_perl  Apache::* ( CPAN)httpd  PerlApache  Perl server API  Perl C
       http://perl.apache.org/

        FCGI ( CPAN)  mod_fastcgi ( http://www.fastcgi.com/) Perl  CGI

        CGI

       http://www.cpan.org/modules/by-category/15_World_Wide_Web_HTML_HTTP_CGI/
       .

       A non-free, commercial product, ``The Velocity Engine for Perl'',
       (http://www.binevolve.com/ or http://www.binevolve.com/velocigen/ )
       might also be worth looking at.  It will allow you to increase the
       performance of your Perl programs, running programs up to 25 times
       faster than normal CGI Perl when running in persistent Perl mode or 4
       to 5 times faster without any modification to your existing CGI
       programs. Fully functional evaluation copies are available from the web
       site.

        Perl?

        :-) ""()

        ? ( CGI) 0755

        (CPAN Filter::*) byte code  (native-code compiler)( Perl)

        Perl  perl  B:: B::Deparse  Perl

       " XYZ..."

        Perl byte code C?

       Malcolm Beattie CPAN perl5.005

        C  Perl  10-30% ()

        Perl eval() libperl.so  perl INSTALL pod perl  /usr/bin/perl 11k""!

       In general, the compiler will do nothing to make a Perl program
       smaller, faster, more portable, or more secure.  In fact, it can make
       your situation worse.  The executable will be bigger, your VM system
       may take longer to load the whole thing, the binary is fragile and hard
       to fix, and compilation never stopped software piracy in the form of
       crackers, viruses, or bootleggers.  The real advantage of the compiler
       is merely packaging, and once you see the size of what it makes (well,
       unless you use a shared libperl.so), you'll probably want a complete
       Perl install anyway.

       How can I compile Perl into Java?

       You can also integrate Java and Perl with the Perl Resource Kit from
       O'Reilly and Associates.  See http://www.oreilly.com/catalog/prkunix/ .

       Perl 5.6 comes with Java Perl Lingo, or JPL.  JPL, still in
       development, allows Perl code to be called from Java.  See jpl/README
       in the Perl source tree.

       OS/2

           extproc perl -S -your_switches

        "*.cmd"  ("-S"  cmd.exe `extproc')DOS batch  ALTERNATIVE_SHEBANG (
       INSTALL)

       The Win95/NT installation, when using the ActiveState port of Perl,
       will modify the Registry to associate the ".pl" extension with the perl
       interpreter.  If you install another port, perhaps even building your
       own Win95/NT Perl from the standard sources by using a Windows port of
       gcc (e.g., with cygwin or mingw32), then you'll have to modify the
       Registry yourself.  In addition to associating ".pl" with the
       interpreter, NT people can use: "SET PATHEXT=%PATHEXT%;.PL" to let them
       run the program "install-linux.pl" merely by typing "install-linux".

        perl (Creator and Type) perl

       : perl  cgi-bin web

       ?

        perlrun ( Unix shell)

           #
           perl -lane 'print $F[0] + $F[-1]' *

           #
           perl -le 'for(@ARGV) {print if -f && -T _}' *

           #  C
           perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c

           #  reaper daemons
           perl -e '$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)' *

           #  uid
           perl -le '$i++ while getpwuid($i); print $i'

           #  (manpath)
           echo $PATH | perl -nl -072 -e '
               s![^/+]*$!man!&&-d&&!$s{$_}++&&push@m,$_;END{print"@m"}'

       perl (Obfuscated Perl)  :-)

        perl  DOS/Mac/VMS?

        Unix shells  perl   Unix Plan9 % %%

           # Unix
           perl -e 'print "Hello world\n"'

           # DOS
           perl -e "print \"Hello world\n\""

           # Mac
           print "Hello world\n"
            ( "Myscript"  Shift-Command-R)

           # MPW
           perl -e 'print "Hello world\n"'

           # VMS
           perl -e "print ""Hello world\n"""

        Unix DOS 4DOS

         perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""

        Mac  MacPerl shell MPW  Unix shells Mac  ASCII

       Using qq(), q(), and qx(), instead of "double quotes", 'single quotes',
       and `backticks`, may make one-liners easier to write.

       [ Kenneth Albanowski ]

        Perl CGI Web?

        CPAN CGI  LWP  web  web" 500"""

               http://www.perl.org/CGI_MetaFAQ.html

        Perl

       perltoot perlobj  perlbootPerltootperltooc  perlbot ( Perl
       http://www.perldoc.com/  perl)

        Perl  OO  "Object-Oriented Perl"  Damian Conway  Manning Publications,
       http://www.manning.com/Conway/index.html

        Perl  C [h2xs, xsubpp]

        Perl C perlxstut perlxs xsubpp  perlguts perlembed perlcall  perlguts

        perlembed,perlguts  C  perl

        CPAN  ExtUtils::Embed  `make test' pod  perlbug "make test
       TEST_VERBOSE=1"  "perl -V"

       perldiag perl splain ( perl)

           perl program 2>diag.out
           splain [-v] [-p] diag.out

           use diagnostics;

           use diagnostics -verbose;

        What's MakeMaker?

        ( perl ) Makefile.PL  Makefile ExtUtils::MakeMaker

AUTHOR AND COPYRIGHT

       Copyright (c) 1997-2002 Tom Christiansen and Nathan Torkington.  All
       rights reserved.

       This documentation is free; you can redistribute it and/or modify it
       under the same terms as Perl itself.

       Irrespective of its distribution, all code examples here are in the
       public domain.  You are permitted and encouraged to use this code and
       any derivatives thereof in your own programs for fun or for profit as
       you see fit.  A simple comment in the code giving credit to the FAQ
       would be courteous but is not required.