{
"mode": "perldoc",
"parameter": "L",
"section": "-q",
"url": "https://www.chedong.com/phpMan.php/perldoc/L/json",
"generated": "2026-10-10T16:53:56Z",
"sections": {
"Found in /usr/share/perl/5.38/pod/perlfaq1.pod": {
"content": "What is Perl?\nPerl is a high-level programming language with an eclectic heritage\nwritten by Larry Wall and a cast of thousands.\n\nPerl's process, file, and text manipulation facilities make it\nparticularly well-suited for tasks involving quick prototyping, system\nutilities, software tools, system management tasks, database access,\ngraphical programming, networking, and web programming.\n\nPerl derives from the ubiquitous C programming language and to a lesser\nextent from sed, awk, the Unix shell, and many other tools and\nlanguages.\n\nThese strengths make it especially popular with web developers and\nsystem administrators. Mathematicians, geneticists, journalists,\nmanagers and many other people also use Perl.\n\nWho supports Perl? Who develops it? Why is it free?\nThe original culture of the pre-populist Internet and the deeply-held\nbeliefs of Perl's author, Larry Wall, gave rise to the free and open\ndistribution policy of Perl. Perl is supported by its users. The core,\nthe standard Perl library, the optional modules, and the documentation\nyou're reading now were all written by volunteers.\n\nThe core development team (known as the Perl Porters) are a group of\nhighly altruistic individuals committed to producing better software for\nfree than you could hope to purchase for money. You may snoop on pending\ndevelopments via the archives\n or you can\nsubscribe to the mailing list by sending\nperl5-porters-subscribe@perl.org a subscription request (an empty\nmessage with no subject is fine).\n\nWhile the GNU project includes Perl in its distributions, there's no\nsuch thing as \"GNU Perl\". Perl is not produced nor maintained by the\nFree Software Foundation. Perl's licensing terms are also more open than\nGNU software's tend to be.\n\nYou can get commercial support of Perl if you wish, although for most\nusers the informal support will more than suffice. See the answer to\n\"Where can I buy a commercial version of Perl?\" for more information.\n\nWhich version of Perl should I use?\n(contributed by brian d foy with updates from others)\n\nThere is often a matter of opinion and taste, and there isn't any one\nanswer that fits everyone. In general, you want to use either the\ncurrent stable release, or the stable release immediately prior to that\none.\n\nBeyond that, you have to consider several things and decide which is\nbest for you.\n\n* If things aren't broken, upgrading perl may break them (or at least\nissue new warnings).\n\n* The latest versions of perl have more bug fixes.\n\n* The latest versions of perl may contain performance improvements and\nfeatures not present in older versions. There have been many changes\nin perl since perl5 was first introduced.\n\n* The Perl community is geared toward supporting the most recent\nreleases, so you'll have an easier time finding help for those.\n\n* Older versions of perl may have security vulnerabilities, some of\nwhich are serious (see perlsec and search CVEs\n for more\ninformation).\n\n* The latest versions are probably the least deployed and widely\ntested, so you may want to wait a few months after their release and\nsee what problems others have if you are risk averse.\n\n* The immediate, in addition to the current stable release, the\nprevious stable release is maintained. See \"MAINTENANCE AND SUPPORT\"\nin perlpolicy for more information.\n\n* There are really two tracks of perl development: a maintenance\nversion and an experimental version. The maintenance versions are\nstable, and have an even number as the minor release (i.e.\nperl5.24.x, where 24 is the minor release). The experimental\nversions may include features that don't make it into the stable\nversions, and have an odd number as the minor release (i.e.\nperl5.25.x, where 25 is the minor release).\n\n* You can consult releases to determine\nthe current stable release of Perl.\n\nWhat are Perl 4, Perl 5, or Raku (Perl 6)?\nIn short, Perl 4 is the parent to both Perl 5 and Raku (formerly known\nas Perl 6). Perl 5 is the older sibling, and though they are different\nlanguages, someone who knows one will spot many similarities in the\nother.\n\nThe number after Perl (i.e. the 5 after Perl 5) is the major release of\nthe perl interpreter as well as the version of the language. Each major\nversion has significant differences that earlier versions cannot\nsupport.\n\nThe current major release of Perl is Perl 5, first released in 1994. It\ncan run scripts from the previous major release, Perl 4 (March 1991),\nbut has significant differences.\n\nRaku is a reinvention of Perl, a language in the same lineage but not\ncompatible. The two are complementary, not mutually exclusive. Raku is\nnot meant to replace Perl, and vice versa. See \"What is Raku (Perl 6)?\"\nbelow to find out more.\n\nSee perlhist for a history of Perl revisions.\n\nWhat is Raku (Perl 6)?\nRaku (formerly known as Perl 6) was *originally* described as the\ncommunity's rewrite of Perl, however as the language evolved, it became\nclear that it is a separate language, but in the same language family as\nPerl.\n\nRaku is not intended primarily as a replacement for Perl, but as its own\nthing - and libraries exist to allow you to call Perl code from Raku\nprograms and vice versa.\n\nContrary to popular belief, Raku and Perl peacefully coexist with one\nanother. Raku has proven to be a fascinating source of ideas for those\nusing Perl (the Moose object system is a well-known example). There is\noverlap in the communities, and this overlap fosters the tradition of\nsharing and borrowing that have been instrumental to Perl's success.\n\nFor more about Raku see .\n\n\"We're really serious about reinventing everything that needs\nreinventing.\" --Larry Wall\n\nHow stable is Perl?\nProduction releases, which incorporate bug fixes and new functionality,\nare widely tested before release. Since the 5.000 release, we have\naveraged about one production release per year.\n\nThe Perl development team occasionally make changes to the internal core\nof the language, but all possible efforts are made toward backward\ncompatibility.\n\nHow often are new versions of Perl released?\nRecently, the plan has been to release a new version of Perl roughly\nevery April, but getting the release right is more important than\nsticking rigidly to a calendar date, so the release date is somewhat\nflexible. The historical release dates can be viewed at\n.\n\nEven numbered minor versions (5.14, 5.16, 5.18) are production versions,\nand odd numbered minor versions (5.15, 5.17, 5.19) are development\nversions. Unless you want to try out an experimental feature, you\nprobably never want to install a development version of Perl.\n\nThe Perl development team are called Perl 5 Porters, and their\norganization is described at .\nThe organizational rules really just boil down to one: Larry is always\nright, even when he was wrong.\n\nIs Perl difficult to learn?\nNo, Perl is easy to start learning --and easy\nto keep learning. It looks like most programming languages you're likely\nto have experience with, so if you've ever written a C program, an awk\nscript, a shell script, or even a BASIC program, you're already partway\nthere.\n\nMost tasks only require a small subset of the Perl language. One of the\nguiding mottos for Perl development is \"there's more than one way to do\nit\" (TMTOWTDI, sometimes pronounced \"tim toady\"). Perl's learning curve\nis therefore shallow (easy to learn) and long (there's a whole lot you\ncan do if you really want).\n\nFinally, because Perl is frequently (but not always, and certainly not\nby definition) an interpreted language, you can write your programs and\ntest them without an intermediate compilation step, allowing you to\nexperiment and test/debug quickly and easily. This ease of\nexperimentation flattens the learning curve even more.\n\nThings that make Perl easier to learn: Unix experience, almost any kind\nof programming experience, an understanding of regular expressions, and\nthe ability to understand other people's code. If there's something you\nneed to do, then it's probably already been done, and a working example\nis usually available for free. Don't forget Perl modules, either.\nThey're discussed in Part 3 of this FAQ, along with CPAN\n, which is discussed in Part 2.\n\nHow does Perl compare with other languages like Java, Python, REXX, Scheme, or Tcl?\nPerl can be used for almost any coding problem, even ones which require\nintegrating specialist C code for extra speed. As with any tool it can\nbe used well or badly. Perl has many strengths, and a few weaknesses,\nprecisely which areas are good and bad is often a personal choice.\n\nWhen choosing a language you should also be influenced by the resources\n, testing culture \nand community which surrounds it.\n\nFor comparisons to a specific language it is often best to create a\nsmall project in both languages and compare the results, make sure to\nuse all the resources of each language, as a\nlanguage is far more than just it's syntax.\n\nCan I do [task] in Perl?\nPerl is flexible and extensible enough for you to use on virtually any\ntask, from one-line file-processing tasks to large, elaborate systems.\n\nFor many people, Perl serves as a great replacement for shell scripting.\nFor others, it serves as a convenient, high-level replacement for most\nof what they'd program in low-level languages like C or C++. It's\nultimately up to you (and possibly your management) which tasks you'll\nuse Perl for and which you won't.\n\nIf you have a library that provides an API, you can make any component\nof it available as just another Perl function or variable using a Perl\nextension written in C or C++ and dynamically linked into your main perl\ninterpreter. You can also go the other direction, and write your main\nprogram in C or C++, and then link in some Perl code on the fly, to\ncreate a powerful application. See perlembed.\n\nThat said, there will always be small, focused, special-purpose\nlanguages dedicated to a specific problem domain that are simply more\nconvenient for certain kinds of problems. Perl tries to be all things to\nall people, but nothing special to anyone. Examples of specialized\nlanguages that come to mind include prolog and matlab.\n\nWhen shouldn't I program in Perl?\nOne good reason is when you already have an existing application written\nin another language that's all done (and done well), or you have an\napplication language specifically designed for a certain task (e.g.\nprolog, make).\n\nIf you find that you need to speed up a specific part of a Perl\napplication (not something you often need) you may want to use C, but\nyou can access this from your Perl code with perlxs.\n\nWhat's the difference between \"perl\" and \"Perl\"?\n\"Perl\" is the name of the language. Only the \"P\" is capitalized. The\nname of the interpreter (the program which runs the Perl script) is\n\"perl\" with a lowercase \"p\".\n\nYou may or may not choose to follow this usage. But never write \"PERL\",\nbecause perl is not an acronym.\n\nHow can I convince others to use Perl?\n(contributed by brian d foy)\n\nAppeal to their self interest! If Perl is new (and thus scary) to them,\nfind something that Perl can do to solve one of their problems. That\nmight mean that Perl either saves them something (time, headaches,\nmoney) or gives them something (flexibility, power, testability).\n\nIn general, the benefit of a language is closely related to the skill of\nthe people using that language. If you or your team can be faster,\nbetter, and stronger through Perl, you'll deliver more value. Remember,\npeople often respond better to what they get out of it. If you run into\nresistance, figure out what those people get out of the other choice and\nhow Perl might satisfy that requirement.\n\nYou don't have to worry about finding or paying for Perl; it's freely\navailable and several popular operating systems come with Perl.\nCommunity support in places such as Perlmonks (\n ) and the various Perl mailing lists (\n ) means that you can usually get quick answers\nto your problems.\n\nFinally, keep in mind that Perl might not be the right tool for every\njob. You're a much better advocate if your claims are reasonable and\ngrounded in reality. Dogmatically advocating anything tends to make\npeople discount your message. Be honest about possible disadvantages to\nyour choice of Perl since any choice has trade-offs.\n\nYou might find these links useful:\n\n* \n\n* \n",
"subsections": []
},
"Found in /usr/share/perl/5.38/pod/perlfaq2.pod": {
"content": "What machines support Perl? Where do I get it?\nThe standard release of Perl (the one maintained by the Perl development\nteam) is distributed only in source code form. You can find the latest\nreleases at .\n\nPerl builds and runs on a bewildering number of platforms. Virtually all\nknown and current Unix derivatives are supported (perl's native\nplatform), as are other systems like VMS, DOS, OS/2, Windows, QNX, BeOS,\nOS X, MPE/iX and the Amiga.\n\nBinary distributions for some proprietary platforms can be found\n directory. Because these are not part of\nthe standard distribution, they may and in fact do differ from the base\nperl port in a variety of ways. You'll have to check their respective\nrelease notes to see just what the differences are. These differences\ncan be either positive (e.g. extensions for the features of the\nparticular platform that are not supported in the source release of\nperl) or negative (e.g. might be based upon a less current source\nrelease of perl).\n\nHow can I get a binary version of Perl?\nSee CPAN Ports \n\nI don't have a C compiler. How can I build my own Perl interpreter?\nFor Windows, use a binary version of Perl, Strawberry Perl\n and ActivePerl\n come with a bundled C compiler.\n\nOtherwise if you really do want to build Perl, you need to get a binary\nversion of \"gcc\" for your system first. Use a search engine to find out\nhow to do this for your operating system.\n\nI copied the Perl binary from one machine to another, but scripts don't work.\nThat's probably because you forgot libraries, or library paths differ.\nYou really should build the whole distribution on the machine it will\neventually live on, and then type \"make install\". Most other approaches\nare doomed to failure.\n\nOne simple way to check that things are in the right place is to print\nout the hard-coded @INC that perl looks through for libraries:\n\n% perl -le 'print for @INC'\n\nIf this command lists any paths that don't exist on your system, then\nyou may need to move the appropriate libraries to these locations, or\ncreate symbolic links, aliases, or shortcuts appropriately. @INC is also\nprinted as part of the output of\n\n% perl -V\n\nYou might also want to check out \"How do I keep my own module/library\ndirectory?\" in perlfaq8.\n\nI grabbed the sources and tried to compile but gdbm/dynamic loading/malloc/linking/... failed. How do I make it work?\nRead the INSTALL file, which is part of the source distribution. It\ndescribes in detail how to cope with most idiosyncrasies that the\n\"Configure\" script can't work around for any given system or\narchitecture.\n\nWhat modules and extensions are available for Perl? What is CPAN?\nCPAN stands for Comprehensive Perl Archive Network, a multi-gigabyte\narchive replicated on hundreds of machines all over the world. CPAN\ncontains tens of thousands of modules and extensions, source code and\ndocumentation, designed for *everything* from commercial database\ninterfaces to keyboard/screen control and running large web sites.\n\nYou can search CPAN on .\n\nThe master web site for CPAN is ,\n lists all mirrors.\n\nSee the CPAN FAQ at for answers\nto the most frequently asked questions about CPAN.\n\nThe Task::Kensho module has a list of recommended modules which you\nshould review as a good starting point.\n\nWhere can I get information on Perl?\n* \n\n* \n\n* \n\nThe complete Perl documentation is available with the Perl distribution.\nIf you have Perl installed locally, you probably have the documentation\ninstalled as well: type \"perldoc perl\" in a terminal or view online\n.\n\n(Some operating system distributions may ship the documentation in a\ndifferent package; for instance, on Debian, you need to install the\n\"perl-doc\" package.)\n\nMany good books have been written about Perl--see the section later in\nperlfaq2 for more details.\n\nWhat is perl.com? Perl Mongers? pm.org? perl.org? cpan.org?\nPerl.com used to be part of the O'Reilly Network,\na subsidiary of O'Reilly Media. Although it retains most of the original\ncontent from its O'Reilly Network, it is now hosted by The Perl\nFoundation .\n\nThe Perl Foundation is an advocacy organization for the Perl language\nwhich maintains the web site as a general\nadvocacy site for the Perl language. It uses the domain to provide\ngeneral support services to the Perl community, including the hosting of\nmailing lists, web sites, and other services. There are also many other\nsub-domains for special topics like learning Perl and jobs in Perl, such\nas:\n\n* \n\n* \n\n* \n\n* \n\nPerl Mongers uses the pm.org domain for services\nrelated to local Perl user groups, including the hosting of mailing\nlists and web sites. See the Perl Mongers web site \nfor more information about joining, starting, or requesting services for\na Perl user group.\n\nCPAN, or the Comprehensive Perl Archive Network ,\nis a replicated, worldwide repository of Perl software. See What is\nCPAN?.\n",
"subsections": [
{
"name": "Perl Books",
"content": "There are many good books on Perl\n.\n\nWhich magazines have Perl content?\nThere's also *$foo Magazin*, a German magazine dedicated to Perl, at (\n ). The *Perl-Zeitung* is another\nGerman-speaking magazine for Perl beginners (see\n ).\n\nSeveral Unix/Linux related magazines frequently include articles on\nPerl.\n\nWhich Perl blogs should I read?\nPerl News covers some of the major events in the\nPerl world, Perl Weekly is a weekly e-mail (and\nRSS feed) of hand-picked Perl articles.\n\n hosts many Perl blogs, there are also several\nblog aggregators: Perlsphere and IronMan\n are two of them.\n\nWhat mailing lists are there for Perl?\nA comprehensive list of Perl-related mailing lists can be found at\n\n\nWhere can I buy a commercial version of Perl?\nPerl already *is* commercial software: it has a license that you can\ngrab and carefully read to your manager. It is distributed in releases\nand comes in well-defined packages. There is a very large and supportive\nuser community and an extensive literature.\n\nIf you still need commercial support ActiveState\n offers this.\n"
}
]
},
"Found in /usr/share/perl/5.38/pod/perlfaq3.pod": {
"content": "How can I use Perl interactively?\nThe typical approach uses the Perl debugger, described in the",
"subsections": [
{
"name": "perldebug",
"content": "perl -de 42\n\nNow just type in any legal Perl code, and it will be immediately\nevaluated. You can also examine the symbol table, get stack backtraces,\ncheck variable values, set breakpoints, and other operations typically\nfound in symbolic debuggers.\n\nYou can also use Devel::REPL which is an interactive shell for Perl,\ncommonly known as a REPL - Read, Evaluate, Print, Loop. It provides\nvarious handy features.\n\nHow do I find which modules are installed on my system?\nFrom the command line, you can use the \"cpan\" command's \"-l\" switch:\n\n$ cpan -l\n\nYou can also use \"cpan\"'s \"-a\" switch to create an autobundle file that\n\"CPAN.pm\" understands and can use to re-install every module:\n\n$ cpan -a\n\nInside a Perl program, you can use the ExtUtils::Installed module to\nshow all installed distributions, although it can take awhile to do its\nmagic. The standard library which comes with Perl just shows up as\n\"Perl\" (although you can get those with Module::CoreList).\n\nuse ExtUtils::Installed;\n\nmy $inst = ExtUtils::Installed->new();\nmy @modules = $inst->modules();\n\nIf you want a list of all of the Perl module filenames, you can use\nFile::Find::Rule:\n\nuse File::Find::Rule;\n\nmy @files = File::Find::Rule->\nextras({follow => 1})->\nfile()->\nname( '*.pm' )->\nin( @INC )\n;\n\nIf you do not have that module, you can do the same thing with\nFile::Find which is part of the standard library:\n\nuse File::Find;\nmy @files;\n\nfind(\n{\nwanted => sub {\npush @files, $File::Find::fullname\nif -f $File::Find::fullname && /\\.pm$/\n},\nfollow => 1,\nfollowskip => 2,\n},\n@INC\n);\n\nprint join \"\\n\", @files;\n\nIf you simply need to check quickly to see if a module is available, you\ncan check for its documentation. If you can read the documentation the\nmodule is most likely installed. If you cannot read the documentation,\nthe module might not have any (in rare cases):\n\n$ perldoc Module::Name\n\nYou can also try to include the module in a one-liner to see if perl\nfinds it:\n\n$ perl -MModule::Name -e1\n\n(If you don't receive a \"Can't locate ... in @INC\" error message, then\nPerl found the module name you asked for.)\n\nHow do I debug my Perl programs?\n(contributed by brian d foy)\n\nBefore you do anything else, you can help yourself by ensuring that you\nlet Perl tell you about problem areas in your code. By turning on\nwarnings and strictures, you can head off many problems before they get\ntoo big. You can find out more about these in strict and warnings.\n\n#!/usr/bin/perl\nuse strict;\nuse warnings;\n\nBeyond that, the simplest debugger is the \"print\" function. Use it to\nlook at values as you run your program:\n\nprint STDERR \"The value is [$value]\\n\";\n\nThe Data::Dumper module can pretty-print Perl data structures:\n\nuse Data::Dumper qw( Dumper );\nprint STDERR \"The hash is \" . Dumper( \\%hash ) . \"\\n\";\n\nPerl comes with an interactive debugger, which you can start with the\n\"-d\" switch. It's fully explained in perldebug.\n\nIf you'd like a graphical user interface and you have Tk, you can use\n\"ptkdb\". It's on CPAN and available for free.\n\nIf you need something much more sophisticated and controllable, Leon\nBrocard's Devel::ebug (which you can call with the \"-D\" switch as\n\"-Debug\") gives you the programmatic hooks into everything you need to\nwrite your own (without too much pain and suffering).\n\nYou can also use a commercial debugger such as Affrus (Mac OS X), Komodo\nfrom Activestate (Windows and Mac OS X), or EPIC (most platforms).\n\nHow do I profile my Perl programs?\n(contributed by brian d foy, updated Fri Jul 25 12:22:26 PDT 2008)\n\nThe \"Devel\" namespace has several modules which you can use to profile\nyour Perl programs.\n\nThe Devel::NYTProf (New York Times Profiler) does both statement and\nsubroutine profiling. It's available from CPAN and you also invoke it\nwith the \"-d\" switch:\n\nperl -d:NYTProf someperl.pl\n\nIt creates a database of the profile information that you can turn into\nreports. The \"nytprofhtml\" command turns the data into an HTML report\nsimilar to the Devel::Cover report:\n\nnytprofhtml\n\nYou might also be interested in using the Benchmark to measure and\ncompare code snippets.\n\nYou can read more about profiling in *Programming Perl*, chapter 20, or\n*Mastering Perl*, chapter 5.\n\nperldebguts documents creating a custom debugger if you need to create a\nspecial sort of profiler. brian d foy describes the process in *The Perl\nJournal*, \"Creating a Perl Debugger\", ,\nand \"Profiling in Perl\" .\n\nPerl.com has two interesting articles on profiling: \"Profiling Perl\", by\nSimon Cozens, and\n\"Debugging and Profiling modperl Applications\", by Frank Wiles,\n .\n\nRandal L. Schwartz writes about profiling in \"Speeding up Your Perl\nPrograms\" for *Unix Review*,\n , and\n\"Profiling in Template Toolkit via Overriding\" for *Linux Magazine*,\n .\n\nHow do I cross-reference my Perl programs?\nThe B::Xref module can be used to generate cross-reference reports for\nPerl programs.\n\nperl -MO=Xref[,OPTIONS] scriptname.plx\n\nIs there a pretty-printer (formatter) for Perl?\nPerl::Tidy comes with a perl script perltidy which indents and reformats\nPerl scripts to make them easier to read by trying to follow the rules\nof the perlstyle. If you write Perl, or spend much time reading Perl,\nyou will probably find it useful.\n\nOf course, if you simply follow the guidelines in perlstyle, you\nshouldn't need to reformat. The habit of formatting your code as you\nwrite it will help prevent bugs. Your editor can and should help you\nwith this. The perl-mode or newer cperl-mode for emacs can provide\nremarkable amounts of help with most (but not all) code, and even less\nprogrammable editors can provide significant assistance. Tom\nChristiansen and many other VI users swear by the following settings in\nvi and its clones:\n\nset ai sw=4\nmap! ^O {^M}^[O^T\n\nPut that in your .exrc file (replacing the caret characters with control\ncharacters) and away you go. In insert mode, ^T is for indenting, ^D is\nfor undenting, and ^O is for blockdenting--as it were. A more complete\nexample, with comments, can be found at\n\n\nIs there an IDE or Windows Perl Editor?\nPerl programs are just plain text, so any editor will do.\n\nIf you're on Unix, you already have an IDE--Unix itself. The Unix\nphilosophy is the philosophy of several small tools that each do one\nthing and do it well. It's like a carpenter's toolbox.\n\nIf you want an IDE, check the following (in alphabetical order, not\norder of preference):\n\nEclipse\n\n\nThe Eclipse Perl Integration Project integrates Perl\nediting/debugging with Eclipse.\n\nEnginsite\n\n\nPerl Editor by EngInSite is a complete integrated development\nenvironment (IDE) for creating, testing, and debugging Perl scripts;\nthe tool runs on Windows 9x/NT/2000/XP or later.\n\nIntelliJ IDEA\n\n\nCamelcade plugin provides Perl5 support in IntelliJ IDEA and other\nJetBrains IDEs.\n\nKephra\n\n\nGUI editor written in Perl using wxWidgets and Scintilla with lots\nof smaller features. Aims for a UI based on Perl principles like\nTIMTOWTDI and \"easy things should be easy, hard things should be\npossible\".\n\nKomodo\n\n\nActiveState's cross-platform (as of October 2004, that's Windows,\nLinux, and Solaris), multi-language IDE has Perl support, including\na regular expression debugger and remote debugging.\n\nNotepad++\n\n\nOpen Perl IDE\n\n\nOpen Perl IDE is an integrated development environment for writing\nand debugging Perl scripts with ActiveState's ActivePerl\ndistribution under Windows 95/98/NT/2000.\n\nOptiPerl\n\n\nOptiPerl is a Windows IDE with simulated CGI environment, including\ndebugger and syntax-highlighting editor.\n\nPadre\n\n\nPadre is cross-platform IDE for Perl written in Perl using wxWidgets\nto provide a native look and feel. It's open source under the\nArtistic License. It is one of the newer Perl IDEs.\n\nPerlBuilder\n\n\nPerlBuilder is an integrated development environment for Windows\nthat supports Perl development.\n\nvisiPerl+\n\n\nFrom Help Consulting, for Windows.\n\nVisual Perl\n\n\nVisual Perl is a Visual Studio.NET plug-in from ActiveState.\n\nZeus\n\n\nZeus for Windows is another Win32 multi-language editor/IDE that\ncomes with support for Perl.\n\nFor editors: if you're on Unix you probably have vi or a vi clone\nalready, and possibly an emacs too, so you may not need to download\nanything. In any emacs the cperl-mode (M-x cperl-mode) gives you perhaps\nthe best available Perl editing mode in any editor.\n\nIf you are using Windows, you can use any editor that lets you work with\nplain text, such as NotePad or WordPad. Word processors, such as\nMicrosoft Word or WordPerfect, typically do not work since they insert\nall sorts of behind-the-scenes information, although some allow you to\nsave files as \"Text Only\". You can also download text editors designed\nspecifically for programming, such as Textpad (\n ) and UltraEdit ( \n), among others.\n\nIf you are using MacOS, the same concerns apply. MacPerl (for Classic\nenvironments) comes with a simple editor. Popular external editors are\nBBEdit ( ) or Alpha (\n ). MacOS X users can use\nUnix editors as well.\n\nGNU Emacs\n\n\nMicroEMACS\n\n\nXEmacs\n\n\nJed \n\nor a vi clone such as\n\nVim \n\nVile\n\n\nThe following are Win32 multilanguage editor/IDEs that support Perl:\n\nMultiEdit\n\n\nSlickEdit\n\n\nConTEXT\n\n\nThere is also a toyedit Text widget based editor written in Perl that is\ndistributed with the Tk module on CPAN. The ptkdb (\n ) is a Perl/Tk-based debugger that acts\nas a development environment of sorts. Perl Composer (\n ) is an IDE for Perl/Tk GUI\ncreation.\n\nIn addition to an editor/IDE you might be interested in a more powerful\nshell environment for Win32. Your options include\n\nbash\nfrom the Cygwin package ( )\n\nzsh \n\nCygwin is covered by the GNU General Public License (but that shouldn't\nmatter for Perl use). Cygwin contains (in addition to the shell) a\ncomprehensive set of standard Unix toolkit utilities.\n\nBBEdit and TextWrangler\nare text editors for OS X that have a Perl sensitivity mode (\n ).\n\nWhere can I get Perl macros for vi?\nFor a complete version of Tom Christiansen's vi configuration file, see\n , the\nstandard benchmark file for vi emulators. The file runs best with nvi,\nthe current version of vi out of Berkeley, which incidentally can be\nbuilt with an embedded Perl interpreter--see\n .\n\nWhere can I get perl-mode or cperl-mode for emacs?\nSince Emacs version 19 patchlevel 22 or so, there have been both a\nperl-mode.el and support for the Perl debugger built in. These should\ncome with the standard Emacs 19 distribution.\n\nNote that the perl-mode of emacs will have fits with \"main'foo\" (single\nquote), and mess up the indentation and highlighting. You are probably\nusing \"main::foo\" in new Perl code anyway, so this shouldn't be an\nissue.\n\nFor CPerlMode, see \n\nHow can I use curses with Perl?\nThe Curses module from CPAN provides a dynamically loadable object\nmodule interface to a curses library. A small demo can be found at the\ndirectory ;\nthis program repeats a command and updates the screen as needed,\nrendering rep ps axu similar to top.\n\nHow can I write a GUI (X, Tk, Gtk, etc.) in Perl?\n(contributed by Ben Morrow)\n\nThere are a number of modules which let you write GUIs in Perl. Most GUI\ntoolkits have a perl interface: an incomplete list follows.\n\nTk This works under Unix and Windows, and the current version doesn't\nlook half as bad under Windows as it used to. Some of the gui\nelements still don't 'feel' quite right, though. The interface is\nvery natural and 'perlish', making it easy to use in small scripts\nthat just need a simple gui. It hasn't been updated in a while.\n\nWx This is a Perl binding for the cross-platform wxWidgets toolkit (\n ). It works under Unix, Win32 and Mac OS\nX, using native widgets (Gtk under Unix). The interface follows the\nC++ interface closely, but the documentation is a little sparse for\nsomeone who doesn't know the library, mostly just referring you to\nthe C++ documentation.\n\nGtk and Gtk2\nThese are Perl bindings for the Gtk toolkit ( \n). The interface changed significantly between versions 1 and 2 so\nthey have separate Perl modules. It runs under Unix, Win32 and Mac\nOS X (currently it requires an X server on Mac OS, but a 'native'\nport is underway), and the widgets look the same on every platform:\ni.e., they don't match the native widgets. As with Wx, the Perl\nbindings follow the C API closely, and the documentation requires\nyou to read the C documentation to understand it.\n\nWin32::GUI\nThis provides access to most of the Win32 GUI widgets from Perl.\nObviously, it only runs under Win32, and uses native widgets. The\nPerl interface doesn't really follow the C interface: it's been made\nmore Perlish, and the documentation is pretty good. More advanced\nstuff may require familiarity with the C Win32 APIs, or reference to\nMSDN.\n\nCamelBones\nCamelBones ( ) is a Perl\ninterface to Mac OS X's Cocoa GUI toolkit, and as such can be used\nto produce native GUIs on Mac OS X. It's not on CPAN, as it requires\nframeworks that CPAN.pm doesn't know how to install, but\ninstallation is via the standard OSX package installer. The Perl API\nis, again, very close to the ObjC API it's wrapping, and the\ndocumentation just tells you how to translate from one to the other.\n\nQt There is a Perl interface to TrollTech's Qt toolkit, but it does not\nappear to be maintained.\n\nAthena\nSx is an interface to the Athena widget set which comes with X, but\nagain it appears not to be much used nowadays.\n\nHow can I make my Perl program run faster?\nThe best way to do this is to come up with a better algorithm. This can\noften make a dramatic difference. Jon Bentley's book *Programming\nPearls* (that's not a misspelling!) has some good tips on optimization,\ntoo. Advice on benchmarking boils down to: benchmark and profile to make\nsure you're optimizing the right part, look for better algorithms\ninstead of microtuning your code, and when all else fails consider just\nbuying faster hardware. You will probably want to read the answer to the\nearlier question \"How do I profile my Perl programs?\" if you haven't\ndone so already.\n\nA different approach is to autoload seldom-used Perl code. See the\nAutoSplit and AutoLoader modules in the standard distribution for that.\nOr you could locate the bottleneck and think about writing just that\npart in C, the way we used to take bottlenecks in C code and write them\nin assembler. Similar to rewriting in C, modules that have critical\nsections can be written in C (for instance, the PDL module from CPAN).\n\nIf you're currently linking your perl executable to a shared *libc.so*,\nyou can often gain a 10-25% performance benefit by rebuilding it to link\nwith a static libc.a instead. This will make a bigger perl executable,\nbut your Perl programs (and programmers) may thank you for it. See the\nINSTALL file in the source distribution for more information.\n\nThe undump program was an ancient attempt to speed up Perl program by\nstoring the already-compiled form to disk. This is no longer a viable\noption, as it only worked on a few architectures, and wasn't a good\nsolution anyway.\n\nHow can I make my Perl program take less memory?\nWhen it comes to time-space tradeoffs, Perl nearly always prefers to\nthrow memory at a problem. Scalars in Perl use more memory than strings\nin C, arrays take more than that, and hashes use even more. While\nthere's still a lot to be done, recent releases have been addressing\nthese issues. For example, as of 5.004, duplicate hash keys are shared\namongst all hashes using them, so require no reallocation.\n\nIn some cases, using substr() or vec() to simulate arrays can be highly\nbeneficial. For example, an array of a thousand booleans will take at\nleast 20,000 bytes of space, but it can be turned into one 125-byte bit\nvector--a considerable memory savings. The standard Tie::SubstrHash\nmodule can also help for certain types of data structure. If you're\nworking with specialist data structures (matrices, for instance) modules\nthat implement these in C may use less memory than equivalent Perl\nmodules.\n\nAnother thing to try is learning whether your Perl was compiled with the\nsystem malloc or with Perl's builtin malloc. Whichever one it is, try\nusing the other one and see whether this makes a difference. Information\nabout malloc is in the INSTALL file in the source distribution. You can\nfind out whether you are using perl's malloc by typing \"perl\n-V:usemymalloc\".\n\nOf course, the best way to save memory is to not do anything to waste it\nin the first place. Good programming practices can go a long way toward\nthis:\n\nDon't slurp!\nDon't read an entire file into memory if you can process it line by\nline. Or more concretely, use a loop like this:\n\n#\n# Good Idea\n#\nwhile (my $line = <$filehandle>) {\n# ...\n}\n\ninstead of this:\n\n#\n# Bad Idea\n#\nmy @data = <$filehandle>;\nforeach (@data) {\n# ...\n}\n\nWhen the files you're processing are small, it doesn't much matter\nwhich way you do it, but it makes a huge difference when they start\ngetting larger.\n\nUse map and grep selectively\nRemember that both map and grep expect a LIST argument, so doing\nthis:\n\n@wanted = grep {/pattern/} <$filehandle>;\n\nwill cause the entire file to be slurped. For large files, it's\nbetter to loop:\n\nwhile (<$filehandle>) {\npush(@wanted, $) if /pattern/;\n}\n\nAvoid unnecessary quotes and stringification\nDon't quote large strings unless absolutely necessary:\n\nmy $copy = \"$largestring\";\n\nmakes 2 copies of $largestring (one for $copy and another for the\nquotes), whereas\n\nmy $copy = $largestring;\n\nonly makes one copy.\n\nDitto for stringifying large arrays:\n\n{\nlocal $, = \"\\n\";\nprint @bigarray;\n}\n\nis much more memory-efficient than either\n\nprint join \"\\n\", @bigarray;\n\nor\n\n{\nlocal $\" = \"\\n\";\nprint \"@bigarray\";\n}\n\nPass by reference\nPass arrays and hashes by reference, not by value. For one thing,\nit's the only way to pass multiple lists or hashes (or both) in a\nsingle call/return. It also avoids creating a copy of all the\ncontents. This requires some judgement, however, because any changes\nwill be propagated back to the original data. If you really want to\nmangle (er, modify) a copy, you'll have to sacrifice the memory\nneeded to make one.\n\nTie large variables to disk\nFor \"big\" data stores (i.e. ones that exceed available memory)\nconsider using one of the DB modules to store it on disk instead of\nin RAM. This will incur a penalty in access time, but that's\nprobably better than causing your hard disk to thrash due to massive\nswapping.\n\nIs it safe to return a reference to local or lexical data?\nYes. Perl's garbage collection system takes care of this so everything\nworks out right.\n\nsub makeone {\nmy @a = ( 1 .. 10 );\nreturn \\@a;\n}\n\nfor ( 1 .. 10 ) {\npush @many, makeone();\n}\n\nprint $many[4][5], \"\\n\";\n\nprint \"@many\\n\";\n\nHow can I hide the source for my Perl program?\nDelete it. :-) Seriously, there are a number of (mostly unsatisfactory)\nsolutions with varying levels of \"security\".\n\nFirst of all, however, you *can't* take away read permission, because\nthe source code has to be readable in order to be compiled and\ninterpreted. (That doesn't mean that a CGI script's source is readable\nby people on the web, though--only by people with access to the\nfilesystem.) So you have to leave the permissions at the socially\nfriendly 0755 level.\n\nSome people regard this as a security problem. If your program does\ninsecure things and relies on people not knowing how to exploit those\ninsecurities, it is not secure. It is often possible for someone to\ndetermine the insecure things and exploit them without viewing the\nsource. Security through obscurity, the name for hiding your bugs\ninstead of fixing them, is little security indeed.\n\nYou can try using encryption via source filters (Starting from Perl 5.8\nthe Filter::Simple and Filter::Util::Call modules are included in the\nstandard distribution), but any decent programmer will be able to\ndecrypt it. You can try using the byte code compiler and interpreter\ndescribed later in perlfaq3, but the curious might still be able to\nde-compile it. You can try using the native-code compiler described\nlater, but crackers might be able to disassemble it. These pose varying\ndegrees of difficulty to people wanting to get at your code, but none\ncan definitively conceal it (true of every language, not just Perl).\n\nIt is very easy to recover the source of Perl programs. You simply feed\nthe program to the perl interpreter and use the modules in the B::\nhierarchy. The B::Deparse module should be able to defeat most attempts\nto hide source. Again, this is not unique to Perl.\n\nIf you're concerned about people profiting from your code, then the\nbottom line is that nothing but a restrictive license will give you\nlegal security. License your software and pepper it with threatening\nstatements like \"This is unpublished proprietary software of XYZ Corp.\nYour access to it does not give you permission to use it blah blah\nblah.\" We are not lawyers, of course, so you should see a lawyer if you\nwant to be sure your license's wording will stand up in court.\n\nHow can I compile my Perl program into byte code or C?\n(contributed by brian d foy)\n\nIn general, you can't do this. There are some things that may work for\nyour situation though. People usually ask this question because they\nwant to distribute their works without giving away the source code, and\nmost solutions trade disk space for convenience. You probably won't see\nmuch of a speed increase either, since most solutions simply bundle a\nPerl interpreter in the final product (but see \"How can I make my Perl\nprogram run faster?\").\n\nThe Perl Archive Toolkit is Perl's analog to Java's JAR. It's freely\navailable and on CPAN ( ).\n\nThere are also some commercial products that may work for you, although\nyou have to buy a license for them.\n\nThe Perl Dev Kit ( )\nfrom ActiveState can \"Turn your Perl programs into ready-to-run\nexecutables for HP-UX, Linux, Solaris and Windows.\"\n\nPerl2Exe ( ) is a command line\nprogram for converting perl scripts to executable files. It targets both\nWindows and Unix platforms.\n\nHow can I get \"#!perl\" to work on [MS-DOS,NT,...]?\nFor OS/2 just use\n\nextproc perl -S -yourswitches\n\nas the first line in \"*.cmd\" file (\"-S\" due to a bug in cmd.exe's\n\"extproc\" handling). For DOS one should first invent a corresponding\nbatch file and codify it in \"ALTERNATESHEBANG\" (see the dosish.h file\nin the source distribution for more information).\n\nThe Win95/NT installation, when using the ActiveState port of Perl, will\nmodify the Registry to associate the \".pl\" extension with the perl\ninterpreter. If you install another port, perhaps even building your own\nWin95/NT Perl from the standard sources by using a Windows port of gcc\n(e.g., with cygwin or mingw32), then you'll have to modify the Registry\nyourself. In addition to associating \".pl\" with the interpreter, NT\npeople can use: \"SET PATHEXT=%PATHEXT%;.PL\" to let them run the program\n\"install-linux.pl\" merely by typing \"install-linux\".\n\nUnder \"Classic\" MacOS, a perl program will have the appropriate Creator\nand Type, so that double-clicking them will invoke the MacPerl\napplication. Under Mac OS X, clickable apps can be made from any \"#!\"\nscript using Wil Sanchez' DropScript utility:\n .\n\n*IMPORTANT!*: Whatever you do, PLEASE don't get frustrated, and just\nthrow the perl interpreter into your cgi-bin directory, in order to get\nyour programs working for a web server. This is an EXTREMELY big\nsecurity risk. Take the time to figure out how to do it correctly.\n\nCan I write useful Perl programs on the command line?\nYes. Read perlrun for more information. Some examples follow. (These\nassume standard Unix shell quoting rules.)\n\n# sum first and last fields\nperl -lane 'print $F[0] + $F[-1]' *\n\n# identify text files\nperl -le 'for(@ARGV) {print if -f && -T }' *\n\n# remove (most) comments from C program\nperl -0777 -pe 's{/\\*.*?\\*/}{}gs' foo.c\n\n# make file a month younger than today, defeating reaper daemons\nperl -e '$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)' *\n\n# find first unused uid\nperl -le '$i++ while getpwuid($i); print $i'\n\n# display reasonable manpath\necho $PATH | perl -nl -072 -e '\ns![^/+]*$!man!&&-d&&!$s{$}++&&push@m,$;END{print\"@m\"}'\n\nOK, the last one was actually an Obfuscated Perl Contest entry. :-)\n\nWhy don't Perl one-liners work on my DOS/Mac/VMS system?\nThe problem is usually that the command interpreters on those systems\nhave rather different ideas about quoting than the Unix shells under\nwhich the one-liners were created. On some systems, you may have to\nchange single-quotes to double ones, which you must *NOT* do on Unix or\nPlan9 systems. You might also have to change a single % to a %%.\n\nFor example:\n\n# Unix (including Mac OS X)\nperl -e 'print \"Hello world\\n\"'\n\n# DOS, etc.\nperl -e \"print \\\"Hello world\\n\\\"\"\n\n# Mac Classic\nprint \"Hello world\\n\"\n(then Run \"Myscript\" or Shift-Command-R)\n\n# MPW\nperl -e 'print \"Hello world\\n\"'\n\n# VMS\nperl -e \"print \"\"Hello world\\n\"\"\"\n\nThe problem is that none of these examples are reliable: they depend on\nthe command interpreter. Under Unix, the first two often work. Under\nDOS, it's entirely possible that neither works. If 4DOS was the command\nshell, you'd probably have better luck like this:\n\nperl -e \"print \"Hello world\\n\"\"\n\nUnder the Mac, it depends which environment you are using. The MacPerl\nshell, or MPW, is much like Unix shells in its support for several\nquoting variants, except that it makes free use of the Mac's non-ASCII\ncharacters as control characters.\n\nUsing qq(), q(), and qx(), instead of \"double quotes\", 'single quotes',\nand `backticks`, may make one-liners easier to write.\n\nThere is no general solution to all of this. It is a mess.\n\n[Some of this answer was contributed by Kenneth Albanowski.]\n\nWhere can I learn about CGI or Web programming in Perl?\nFor modules, get the CGI or LWP modules from CPAN. For textbooks, see\nthe two especially dedicated to web stuff in the question on books. For\nproblems and questions related to the web, like \"Why do I get 500\nErrors\" or \"Why doesn't it run from the browser right when it runs fine\non the command line\", see the troubleshooting guides and references in\nperlfaq9 or in the CGI MetaFAQ:\n\nL\n\nLooking into and modern Perl web frameworks is\nhighly recommended, though; web programming in Perl has evolved a long\nway from the old days of simple CGI scripts.\n\nWhere can I learn about object-oriented Perl programming?\nA good place to start is perlootut, and you can use perlobj for\nreference.\n\nA good book on OO on Perl is the \"Object-Oriented Perl\" by Damian Conway\nfrom Manning Publications, or \"Intermediate Perl\" by Randal Schwartz,\nbrian d foy, and Tom Phoenix from O'Reilly Media.\n\nWhere can I learn about linking C with Perl?\nIf you want to call C from Perl, start with perlxstut, moving on to\nperlxs, xsubpp, and perlguts. If you want to call Perl from C, then read\nperlembed, perlcall, and perlguts. Don't forget that you can learn a lot\nfrom looking at how the authors of existing extension modules wrote\ntheir code and solved their problems.\n\nYou might not need all the power of XS. The Inline::C module lets you\nput C code directly in your Perl source. It handles all the magic to\nmake it work. You still have to learn at least some of the perl API but\nyou won't have to deal with the complexity of the XS support files.\n\nI've read perlembed, perlguts, etc., but I can't embed perl in my C program; what am I doing wrong?\nDownload the ExtUtils::Embed kit from CPAN and run `make test'. If the\ntests pass, read the pods again and again and again. If they fail,\nsubmit a bug report to with the\noutput of \"make test TESTVERBOSE=1\" along with \"perl -V\".\n"
}
]
},
"Found in /usr/share/perl/5.38/pod/perlfaq4.pod": {
"content": "Why am I getting long decimals (eg, 19.9499999999999) instead of the numbers I should be getting (eg, 19.95)?\nFor the long explanation, see David Goldberg's \"What Every Computer\nScientist Should Know About Floating-Point Arithmetic\"\n().\n\nInternally, your computer represents floating-point numbers in binary.\nDigital (as in powers of two) computers cannot store all numbers\nexactly. Some real numbers lose precision in the process. This is a\nproblem with how computers store numbers and affects all computer\nlanguages, not just Perl.\n\nperlnumber shows the gory details of number representations and\nconversions.\n\nTo limit the number of decimal places in your numbers, you can use the\n\"printf\" or \"sprintf\" function. See \"Floating-point Arithmetic\" in\nperlop for more details.\n\nprintf \"%.2f\", 10/3;\n\nmy $number = sprintf \"%.2f\", 10/3;\n\nWhy isn't my octal data interpreted correctly?\n(contributed by brian d foy)\n\nYou're probably trying to convert a string to a number, which Perl only\nconverts as a decimal number. When Perl converts a string to a number,\nit ignores leading spaces and zeroes, then assumes the rest of the\ndigits are in base 10:\n\nmy $string = '0644';\n\nprint $string + 0; # prints 644\n\nprint $string + 44; # prints 688, certainly not octal!\n\nThis problem usually involves one of the Perl built-ins that has the\nsame name a Unix command that uses octal numbers as arguments on the\ncommand line. In this example, \"chmod\" on the command line knows that\nits first argument is octal because that's what it does:\n\n%prompt> chmod 644 file\n\nIf you want to use the same literal digits (644) in Perl, you have to\ntell Perl to treat them as octal numbers either by prefixing the digits\nwith a 0 or using \"oct\":\n\nchmod( 0644, $filename ); # right, has leading zero\nchmod( oct(644), $filename ); # also correct\n\nThe problem comes in when you take your numbers from something that Perl\nthinks is a string, such as a command line argument in @ARGV:\n\nchmod( $ARGV[0], $filename ); # wrong, even if \"0644\"\n\nchmod( oct($ARGV[0]), $filename ); # correct, treat string as octal\n\nYou can always check the value you're using by printing it in octal\nnotation to ensure it matches what you think it should be. Print it in\noctal and decimal format:\n\nprintf \"0%o %d\", $number, $number;\n\nDoes Perl have a round() function? What about ceil() and floor()? Trig functions?\nRemember that int() merely truncates toward 0. For rounding to a certain\nnumber of digits, sprintf() or printf() is usually the easiest route.\n\nprintf(\"%.3f\", 3.1415926535); # prints 3.142\n\nThe POSIX module (part of the standard Perl distribution) implements",
"subsections": [
{
"name": "ceil",
"content": "functions.\n\nuse POSIX;\nmy $ceil = ceil(3.5); # 4\nmy $floor = floor(3.5); # 3\n\nIn 5.000 to 5.003 perls, trigonometry was done in the Math::Complex\nmodule. With 5.004, the Math::Trig module (part of the standard Perl\ndistribution) implements the trigonometric functions. Internally it uses\nthe Math::Complex module and some functions can break out from the real\naxis into the complex plane, for example the inverse sine of 2.\n\nRounding in financial applications can have serious implications, and\nthe rounding method used should be specified precisely. In these cases,\nit probably pays not to trust whichever system of rounding is being used\nby Perl, but instead to implement the rounding function you need\nyourself.\n\nTo see why, notice how you'll still have an issue on half-way-point\nalternation:\n\nfor (my $i = -5; $i <= 5; $i += 0.5) { printf \"%.0f \",$i }\n\n-5 -4 -4 -4 -3 -2 -2 -2 -1 -0 0 0 1 2 2 2 3 4 4 4 5\n\nDon't blame Perl. It's the same as in C. IEEE says we have to do this.\nPerl numbers whose absolute values are integers under 231 (on 32-bit\nmachines) will work pretty much like mathematical integers. Other\nnumbers are not guaranteed.\n\nHow do I multiply matrices?\nUse the Math::Matrix or Math::MatrixReal modules (available from CPAN)\nor the PDL extension (also available from CPAN).\n\nHow can I output Roman numerals?\nGet the module.\n\nHow do I find the current century or millennium?\nUse the following simple functions:\n\nsub getcentury {\nreturn int((((localtime(shift || time))[5] + 1999))/100);\n}\n\nsub getmillennium {\nreturn 1+int((((localtime(shift || time))[5] + 1899))/1000);\n}\n\nOn some systems, the POSIX module's strftime() function has been\nextended in a non-standard way to use a %C format, which they sometimes\nclaim is the \"century\". It isn't, because on most such systems, this is\nonly the first two digits of the four-digit year, and thus cannot be\nused to determine reliably the current century or millennium.\n\nHow can I find the Julian Day?\n(contributed by brian d foy and Dave Cross)\n\nYou can use the Time::Piece module, part of the Standard Library, which\ncan convert a date/time to a Julian Day:\n\n$ perl -MTime::Piece -le 'print localtime->julianday'\n2455607.7959375\n\nOr the modified Julian Day:\n\n$ perl -MTime::Piece -le 'print localtime->mjd'\n55607.2961226851\n\nOr even the day of the year (which is what some people think of as a\nJulian day):\n\n$ perl -MTime::Piece -le 'print localtime->yday'\n45\n\nYou can also do the same things with the DateTime module:\n\n$ perl -MDateTime -le'print DateTime->today->jd'\n2453401.5\n$ perl -MDateTime -le'print DateTime->today->mjd'\n53401\n$ perl -MDateTime -le'print DateTime->today->doy'\n31\n\nYou can use the Time::JulianDay module available on CPAN. Ensure that\nyou really want to find a Julian day, though, as many people have\ndifferent ideas about Julian days (see\n for instance):\n\n$ perl -MTime::JulianDay -le 'print localjulianday( time )'\n55608\n\nDoes Perl have a Year 2000 or 2038 problem? Is Perl Y2K compliant?\n(contributed by brian d foy)\n\nPerl itself never had a Y2K problem, although that never stopped people\nfrom creating Y2K problems on their own. See the documentation for\n\"localtime\" for its proper use.\n\nStarting with Perl 5.12, \"localtime\" and \"gmtime\" can handle dates past\n03:14:08 January 19, 2038, when a 32-bit based time would overflow. You\nstill might get a warning on a 32-bit \"perl\":\n\n% perl5.12 -E 'say scalar localtime( 0x9FFFFFFFFFFF )'\nInteger overflow in hexadecimal number at -e line 1.\nWed Nov 1 19:42:39 5576711\n\nOn a 64-bit \"perl\", you can get even larger dates for those really long\nrunning projects:\n\n% perl5.12 -E 'say scalar gmtime( 0x9FFFFFFFFFFF )'\nThu Nov 2 00:42:39 5576711\n\nYou're still out of luck if you need to keep track of decaying protons\nthough.\n\nHow do I validate input?\n(contributed by brian d foy)\n\nThere are many ways to ensure that values are what you expect or want to\naccept. Besides the specific examples that we cover in the perlfaq, you\ncan also look at the modules with \"Assert\" and \"Validate\" in their\nnames, along with other modules such as Regexp::Common.\n\nSome modules have validation for particular types of input, such as\nBusiness::ISBN, Business::CreditCard, Email::Valid, and\nData::Validate::IP.\n\nHow do I expand function calls in a string?\n(contributed by brian d foy)\n\nThis is documented in perlref, and although it's not the easiest thing\nto read, it does work. In each of these examples, we call the function\ninside the braces used to dereference a reference. If we have more than\none return value, we can construct and dereference an anonymous array.\nIn this case, we call the function in list context.\n\nprint \"The time values are @{ [localtime] }.\\n\";\n\nIf we want to call the function in scalar context, we have to do a bit\nmore work. We can really have any code we like inside the braces, so we\nsimply have to end with the scalar reference, although how you do that\nis up to you, and you can use code inside the braces. Note that the use\nof parens creates a list context, so we need \"scalar\" to force the\nscalar context on the function:\n\nprint \"The time is ${\\(scalar localtime)}.\\n\"\n\nprint \"The time is ${ my $x = localtime; \\$x }.\\n\";\n\nIf your function already returns a reference, you don't need to create\nthe reference yourself.\n\nsub timestamp { my $t = localtime; \\$t }\n\nprint \"The time is ${ timestamp() }.\\n\";\n\nThe \"Interpolation\" module can also do a lot of magic for you. You can\nspecify a variable name, in this case \"E\", to set up a tied hash that\ndoes the interpolation for you. It has several other methods to do this\nas well.\n\nuse Interpolation E => 'eval';\nprint \"The time values are $E{localtime()}.\\n\";\n\nIn most cases, it is probably easier to simply use string concatenation,\nwhich also forces scalar context.\n\nprint \"The time is \" . localtime() . \".\\n\";\n\nHow do I capitalize all the words on one line?\n(contributed by brian d foy)\n\nDamian Conway's Text::Autoformat handles all of the thinking for you.\n\nuse Text::Autoformat;\nmy $x = \"Dr. Strangelove or: How I Learned to Stop \".\n\"Worrying and Love the Bomb\";\n\nprint $x, \"\\n\";\nfor my $style (qw( sentence title highlight )) {\nprint autoformat($x, { case => $style }), \"\\n\";\n}\n\nHow do you want to capitalize those words?\n\nFRED AND BARNEY'S LODGE # all uppercase\nFred And Barney's Lodge # title case\nFred and Barney's Lodge # highlight case\n\nIt's not as easy a problem as it looks. How many words do you think are\nin there? Wait for it... wait for it.... If you answered 5 you're right.\nPerl words are groups of \"\\w+\", but that's not what you want to\ncapitalize. How is Perl supposed to know not to capitalize that \"s\"\nafter the apostrophe? You could try a regular expression:\n\n$string =~ s/ (\n(^\\w) #at the beginning of the line\n| # or\n(\\s\\w) #preceded by whitespace\n)\n/\\U$1/xg;\n\n$string =~ s/([\\w']+)/\\u\\L$1/g;\n\nNow, what if you don't want to capitalize that \"and\"? Just use\nText::Autoformat and get on with the next problem. :)\n\nHow can I split a [character]-delimited string except when inside [character]?\nSeveral modules can handle this sort of parsing--Text::Balanced,\nText::CSV, Text::CSVXS, and Text::ParseWords, among others.\n\nTake the example case of trying to split a string that is\ncomma-separated into its different fields. You can't use \"split(/,/)\"\nbecause you shouldn't split if the comma is inside quotes. For example,\ntake a data line like this:\n\nSAR001,\"\",\"Cimetrix, Inc\",\"Bob Smith\",\"CAM\",N,8,1,0,7,\"Error, Core Dumped\"\n\nDue to the restriction of the quotes, this is a fairly complex problem.\nThankfully, we have Jeffrey Friedl, author of *Mastering Regular\nExpressions*, to handle these for us. He suggests (assuming your string\nis contained in $text):\n\nmy @new = ();\npush(@new, $+) while $text =~ m{\n\"([^\\\"\\\\]*(?:\\\\.[^\\\"\\\\]*)*)\",? # groups the phrase inside the quotes\n| ([^,]+),?\n| ,\n}gx;\npush(@new, undef) if substr($text,-1,1) eq ',';\n\nIf you want to represent quotation marks inside a\nquotation-mark-delimited field, escape them with backslashes (eg, \"like\n\\\"this\\\"\".\n\nAlternatively, the Text::ParseWords module (part of the standard Perl\ndistribution) lets you say:\n\nuse Text::ParseWords;\n@new = quotewords(\",\", 0, $text);\n\nFor parsing or generating CSV, though, using Text::CSV rather than\nimplementing it yourself is highly recommended; you'll save yourself odd\nbugs popping up later by just using code which has already been tried\nand tested in production for years.\n\nHow do I strip blank space from the beginning/end of a string?\n(contributed by brian d foy)\n\nA substitution can do this for you. For a single line, you want to\nreplace all the leading or trailing whitespace with nothing. You can do\nthat with a pair of substitutions:\n\ns/^\\s+//;\ns/\\s+$//;\n\nYou can also write that as a single substitution, although it turns out\nthe combined statement is slower than the separate ones. That might not\nmatter to you, though:\n\ns/^\\s+|\\s+$//g;\n\nIn this regular expression, the alternation matches either at the\nbeginning or the end of the string since the anchors have a lower\nprecedence than the alternation. With the \"/g\" flag, the substitution\nmakes all possible matches, so it gets both. Remember, the trailing\nnewline matches the \"\\s+\", and the \"$\" anchor can match to the absolute\nend of the string, so the newline disappears too. Just add the newline\nto the output, which has the added benefit of preserving \"blank\"\n(consisting entirely of whitespace) lines which the \"^\\s+\" would remove\nall by itself:\n\nwhile( <> ) {\ns/^\\s+|\\s+$//g;\nprint \"$\\n\";\n}\n\nFor a multi-line string, you can apply the regular expression to each\nlogical line in the string by adding the \"/m\" flag (for \"multi-line\").\nWith the \"/m\" flag, the \"$\" matches *before* an embedded newline, so it\ndoesn't remove it. This pattern still removes the newline at the end of\nthe string:\n\n$string =~ s/^\\s+|\\s+$//gm;\n\nRemember that lines consisting entirely of whitespace will disappear,\nsince the first part of the alternation can match the entire string and\nreplace it with nothing. If you need to keep embedded blank lines, you\nhave to do a little more work. Instead of matching any whitespace (since\nthat includes a newline), just match the other whitespace:\n\n$string =~ s/^[\\t\\f ]+|[\\t\\f ]+$//mg;\n\nHow do I pad a string with blanks or pad a number with zeroes?\nIn the following examples, $padlen is the length to which you wish to\npad the string, $text or $num contains the string to be padded, and\n$padchar contains the padding character. You can use a single character\nstring constant instead of the $padchar variable if you know what it is\nin advance. And in the same way you can use an integer in place of\n$padlen if you know the pad length in advance.\n\nThe simplest method uses the \"sprintf\" function. It can pad on the left\nor right with blanks and on the left with zeroes and it will not\ntruncate the result. The \"pack\" function can only pad strings on the\nright with blanks and it will truncate the result to a maximum length of\n$padlen.\n\n# Left padding a string with blanks (no truncation):\nmy $padded = sprintf(\"%${padlen}s\", $text);\nmy $padded = sprintf(\"%*s\", $padlen, $text); # same thing\n\n# Right padding a string with blanks (no truncation):\nmy $padded = sprintf(\"%-${padlen}s\", $text);\nmy $padded = sprintf(\"%-*s\", $padlen, $text); # same thing\n\n# Left padding a number with 0 (no truncation):\nmy $padded = sprintf(\"%0${padlen}d\", $num);\nmy $padded = sprintf(\"%0*d\", $padlen, $num); # same thing\n\n# Right padding a string with blanks using pack (will truncate):\nmy $padded = pack(\"A$padlen\",$text);\n\nIf you need to pad with a character other than blank or zero you can use\none of the following methods. They all generate a pad string with the\n\"x\" operator and combine that with $text. These methods do not truncate\n$text.\n\nLeft and right padding with any character, creating a new string:\n\nmy $padded = $padchar x ( $padlen - length( $text ) ) . $text;\nmy $padded = $text . $padchar x ( $padlen - length( $text ) );\n\nLeft and right padding with any character, modifying $text directly:\n\nsubstr( $text, 0, 0 ) = $padchar x ( $padlen - length( $text ) );\n$text .= $padchar x ( $padlen - length( $text ) );\n\nHow do I extract selected columns from a string?\n(contributed by brian d foy)\n\nIf you know the columns that contain the data, you can use \"substr\" to\nextract a single column.\n\nmy $column = substr( $line, $startcolumn, $length );\n\nYou can use \"split\" if the columns are separated by whitespace or some\nother delimiter, as long as whitespace or the delimiter cannot appear as\npart of the data.\n\nmy $line = ' fred barney betty ';\nmy @columns = split /\\s+/, $line;\n# ( '', 'fred', 'barney', 'betty' );\n\nmy $line = 'fred||barney||betty';\nmy @columns = split /\\|/, $line;\n# ( 'fred', '', 'barney', '', 'betty' );\n\nIf you want to work with comma-separated values, don't do this since\nthat format is a bit more complicated. Use one of the modules that\nhandle that format, such as Text::CSV, Text::CSVXS, or Text::CSVPP.\n\nIf you want to break apart an entire line of fixed columns, you can use\n\"unpack\" with the A (ASCII) format. By using a number after the format\nspecifier, you can denote the column width. See the \"pack\" and \"unpack\"\nentries in perlfunc for more details.\n\nmy @fields = unpack( $line, \"A8 A8 A8 A16 A4\" );\n\nNote that spaces in the format argument to \"unpack\" do not denote\nliteral spaces. If you have space separated data, you may want \"split\"\ninstead.\n\nHow do I find the soundex value of a string?\n(contributed by brian d foy)\n\nYou can use the \"Text::Soundex\" module. If you want to do fuzzy or close\nmatching, you might also try the String::Approx, and Text::Metaphone,\nand Text::DoubleMetaphone modules.\n\nHow can I expand variables in text strings?\n(contributed by brian d foy)\n\nIf you can avoid it, don't, or if you can use a templating system, such\nas Text::Template or Template Toolkit, do that instead. You might even\nbe able to get the job done with \"sprintf\" or \"printf\":\n\nmy $string = sprintf 'Say hello to %s and %s', $foo, $bar;\n\nHowever, for the one-off simple case where I don't want to pull out a\nfull templating system, I'll use a string that has two Perl scalar\nvariables in it. In this example, I want to expand $foo and $bar to\ntheir variable's values:\n\nmy $foo = 'Fred';\nmy $bar = 'Barney';\n$string = 'Say hello to $foo and $bar';\n\nOne way I can do this involves the substitution operator and a double\n\"/e\" flag. The first \"/e\" evaluates $1 on the replacement side and turns\nit into $foo. The second /e starts with $foo and replaces it with its\nvalue. $foo, then, turns into 'Fred', and that's finally what's left in\nthe string:\n\n$string =~ s/(\\$\\w+)/$1/eeg; # 'Say hello to Fred and Barney'\n\nThe \"/e\" will also silently ignore violations of strict, replacing\nundefined variable names with the empty string. Since I'm using the \"/e\"\nflag (twice even!), I have all of the same security problems I have with\n\"eval\" in its string form. If there's something odd in $foo, perhaps\nsomething like \"@{[ system \"rm -rf /\" ]}\", then I could get myself in\ntrouble.\n\nTo get around the security problem, I could also pull the values from a\nhash instead of evaluating variable names. Using a single \"/e\", I can\ncheck the hash to ensure the value exists, and if it doesn't, I can\nreplace the missing value with a marker, in this case \"???\" to signal\nthat I missed something:\n\nmy $string = 'This has $foo and $bar';\n\nmy %Replacements = (\nfoo => 'Fred',\n);\n\n# $string =~ s/\\$(\\w+)/$Replacements{$1}/g;\n$string =~ s/\\$(\\w+)/\nexists $Replacements{$1} ? $Replacements{$1} : '???'\n/eg;\n\nprint $string;\n\nDoes Perl have anything like Ruby's #{} or Python's f string?\nUnlike the others, Perl allows you to embed a variable naked in a double\nquoted string, e.g. \"variable $variable\". When there isn't whitespace or\nother non-word characters following the variable name, you can add\nbraces (e.g. \"foo ${foo}bar\") to ensure correct parsing.\n\nAn array can also be embedded directly in a string, and will be expanded\nby default with spaces between the elements. The default LISTSEPARATOR\ncan be changed by assigning a different string to the special variable\n$\", such as \"local $\" = ', ';\".\n\nPerl also supports references within a string providing the equivalent\nof the features in the other two languages.\n\n\"${\\ ... }\" embedded within a string will work for most simple\nstatements such as an object->method call. More complex code can be\nwrapped in a do block \"${\\ do{...} }\".\n\nWhen you want a list to be expanded per $\", use \"@{[ ... ]}\".\n\nuse Time::Piece;\nuse Time::Seconds;\nmy $scalar = 'STRING';\nmy @array = ( 'zorro', 'a', 1, 'B', 3 );\n\n# Print the current date and time and then Tommorrow\nmy $t = Time::Piece->new;\nsay \"Now is: ${\\ $t->cdate() }\";\nsay \"Tomorrow: ${\\ do{ my $T=Time::Piece->new + ONEDAY ; $T->fullday }}\";\n\n# some variables in strings\nsay \"This is some scalar I have $scalar, this is an array @array.\";\nsay \"You can also write it like this ${scalar} @{array}.\";\n\n# Change the $LISTSEPARATOR\nlocal $\" = ':';\nsay \"Set \\$\\\" to delimit with ':' and sort the Array @{[ sort @array ]}\";\n\nYou may also want to look at the module Quote::Code, and templating\ntools such as Template::Toolkit and Mojo::Template.\n\nSee also: \"How can I expand variables in text strings?\" and \"How do I\nexpand function calls in a string?\" in this FAQ.\n\nWhat's wrong with always quoting \"$vars\"?\nThe problem is that those double-quotes force stringification--coercing\nnumbers and references into strings--even when you don't want them to be\nstrings. Think of it this way: double-quote expansion is used to produce\nnew strings. If you already have a string, why do you need more?\n\nIf you get used to writing odd things like these:\n\nprint \"$var\"; # BAD\nmy $new = \"$old\"; # BAD\nsomefunc(\"$var\"); # BAD\n\nYou'll be in trouble. Those should (in 99.8% of the cases) be the\nsimpler and more direct:\n\nprint $var;\nmy $new = $old;\nsomefunc($var);\n\nOtherwise, besides slowing you down, you're going to break code when the\nthing in the scalar is actually neither a string nor a number, but a\nreference:\n\nfunc(\\@array);\nsub func {\nmy $aref = shift;\nmy $oref = \"$aref\"; # WRONG\n}\n\nYou can also get into subtle problems on those few operations in Perl\nthat actually do care about the difference between a string and a\nnumber, such as the magical \"++\" autoincrement operator or the syscall()\nfunction.\n\nStringification also destroys arrays.\n\nmy @lines = `command`;\nprint \"@lines\"; # WRONG - extra blanks\nprint @lines; # right\n\nWhy don't my <opppaddr)() );\n@@@ TAINTNOT;\n@@@ return 0;\n@@@ }\nMAININTERPRETERLOOP\n\nOr with a fixed amount of leading whitespace, with remaining indentation\ncorrectly preserved:\n\nmy $poem = fix<();\n}\nreturn 0;\n}\n\nIf speed is of little concern, the common idiom uses grep in scalar\ncontext (which returns the number of items that passed its condition) to\ntraverse the entire list. This does have the benefit of telling you how\nmany matches it found, though.\n\nmy $isthere = grep $ eq $whatever, @array;\n\nIf you want to actually extract the matching elements, simply use grep\nin list context.\n\nmy @matches = grep $ eq $whatever, @array;\n\nHow do I test whether two arrays or hashes are equal?\nThe following code works for single-level arrays. It uses a stringwise\ncomparison, and does not distinguish defined versus undefined empty\nstrings. Modify if you have other needs.\n\n$areequal = comparearrays(\\@frogs, \\@toads);\n\nsub comparearrays {\nmy ($first, $second) = @;\nno warnings; # silence spurious -w undef complaints\nreturn 0 unless @$first == @$second;\nfor (my $i = 0; $i < @$first; $i++) {\nreturn 0 if $first->[$i] ne $second->[$i];\n}\nreturn 1;\n}\n\nFor multilevel structures, you may wish to use an approach more like\nthis one. It uses the CPAN module FreezeThaw:\n\nuse FreezeThaw qw(cmpStr);\nmy @a = my @b = ( \"this\", \"that\", [ \"more\", \"stuff\" ] );\n\nprintf \"a and b contain %s arrays\\n\",\ncmpStr(\\@a, \\@b) == 0\n? \"the same\"\n: \"different\";\n\nThis approach also works for comparing hashes. Here we'll demonstrate\ntwo different answers:\n\nuse FreezeThaw qw(cmpStr cmpStrHard);\n\nmy %a = my %b = ( \"this\" => \"that\", \"extra\" => [ \"more\", \"stuff\" ] );\n$a{EXTRA} = \\%b;\n$b{EXTRA} = \\%a;\n\nprintf \"a and b contain %s hashes\\n\",\ncmpStr(\\%a, \\%b) == 0 ? \"the same\" : \"different\";\n\nprintf \"a and b contain %s hashes\\n\",\ncmpStrHard(\\%a, \\%b) == 0 ? \"the same\" : \"different\";\n\nThe first reports that both those the hashes contain the same data,\nwhile the second reports that they do not. Which you prefer is left as\nan exercise to the reader.\n\nHow do I find the first array element for which a condition is true?\nTo find the first array element which satisfies a condition, you can use\nthe first() function in the List::Util module, which comes with Perl\n5.8. This example finds the first element that contains \"Perl\".\n\nuse List::Util qw(first);\n\nmy $element = first { /Perl/ } @array;\n\nIf you cannot use List::Util, you can make your own loop to do the same\nthing. Once you find the element, you stop the loop with last.\n\nmy $found;\nforeach ( @array ) {\nif( /Perl/ ) { $found = $; last }\n}\n\nIf you want the array index, use the firstidx() function from\n\"List::MoreUtils\":\n\nuse List::MoreUtils qw(firstidx);\nmy $index = firstidx { /Perl/ } @array;\n\nOr write it yourself, iterating through the indices and checking the\narray element at each index until you find one that satisfies the\ncondition:\n\nmy( $found, $index ) = ( undef, -1 );\nfor( $i = 0; $i < @array; $i++ ) {\nif( $array[$i] =~ /Perl/ ) {\n$found = $array[$i];\n$index = $i;\nlast;\n}\n}\n\nHow do I handle linked lists?\n(contributed by brian d foy)\n\nPerl's arrays do not have a fixed size, so you don't need linked lists\nif you just want to add or remove items. You can use array operations\nsuch as \"push\", \"pop\", \"shift\", \"unshift\", or \"splice\" to do that.\n\nSometimes, however, linked lists can be useful in situations where you\nwant to \"shard\" an array so you have many small arrays instead of a\nsingle big array. You can keep arrays longer than Perl's largest array\nindex, lock smaller arrays separately in threaded programs, reallocate\nless memory, or quickly insert elements in the middle of the chain.\n\nSteve Lembark goes through the details in his YAPC::NA 2009 talk \"Perly\nLinked Lists\" ( \n), although you can just use his LinkedList::Single module.\n\nHow do I handle circular lists?\n(contributed by brian d foy)\n\nIf you want to cycle through an array endlessly, you can increment the\nindex modulo the number of elements in the array:\n\nmy @array = qw( a b c );\nmy $i = 0;\n\nwhile( 1 ) {\nprint $array[ $i++ % @array ], \"\\n\";\nlast if $i > 20;\n}\n\nYou can also use Tie::Cycle to use a scalar that always has the next\nelement of the circular array:\n\nuse Tie::Cycle;\n\ntie my $cycle, 'Tie::Cycle', [ qw( FFFFFF 000000 FFFF00 ) ];\n\nprint $cycle; # FFFFFF\nprint $cycle; # 000000\nprint $cycle; # FFFF00\n\nThe Array::Iterator::Circular creates an iterator object for circular\narrays:\n\nuse Array::Iterator::Circular;\n\nmy $coloriterator = Array::Iterator::Circular->new(\nqw(red green blue orange)\n);\n\nforeach ( 1 .. 20 ) {\nprint $coloriterator->next, \"\\n\";\n}\n\nHow do I shuffle an array randomly?\nIf you either have Perl 5.8.0 or later installed, or if you have\nScalar-List-Utils 1.03 or later installed, you can say:\n\nuse List::Util 'shuffle';\n\n@shuffled = shuffle(@list);\n\nIf not, you can use a Fisher-Yates shuffle.\n\nsub fisheryatesshuffle {\nmy $deck = shift; # $deck is a reference to an array\nreturn unless @$deck; # must not be empty!\n\nmy $i = @$deck;\nwhile (--$i) {\nmy $j = int rand ($i+1);\n@$deck[$i,$j] = @$deck[$j,$i];\n}\n}\n\n# shuffle my mpeg collection\n#\nmy @mpeg =