2026-11-01 23:52 @216.73.217.84
CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)
Found in /usr/share/perl/5.38/pod/perlfaq1.pod Who supports Perl? Who develops it? Why is it free? The original culture of the pre-populist Internet and the deeply-held beliefs of Perl's author, Larry Wall, gave rise to the free and open distribution policy of Perl. Perl is supported by its users. The core, the standard Perl library, the optional modules, and the documentation you're reading now were all written by volunteers. The core development team (known as the Perl Porters) are a group of highly altruistic individuals committed to producing better software for free than you could hope to purchase for money. You may snoop on pending developments via the archives <http://www.nntp.perl.org/group/perl.perl5.porters/> or you can subscribe to the mailing list by sending perl5-porters-subscribe AT perl.org a subscription request (an empty message with no subject is fine). While the GNU project includes Perl in its distributions, there's no such thing as "GNU Perl". Perl is not produced nor maintained by the Free Software Foundation. Perl's licensing terms are also more open than GNU software's tend to be. You can get commercial support of Perl if you wish, although for most users the informal support will more than suffice. See the answer to "Where can I buy a commercial version of Perl?" for more information. How does Perl compare with other languages like Java, Python, REXX, Scheme, or Tcl? Perl can be used for almost any coding problem, even ones which require integrating specialist C code for extra speed. As with any tool it can be used well or badly. Perl has many strengths, and a few weaknesses, precisely which areas are good and bad is often a personal choice. When choosing a language you should also be influenced by the resources <http://www.cpan.org/>, testing culture <http://www.cpantesters.org/> and community <http://www.perl.org/community.html> which surrounds it. For comparisons to a specific language it is often best to create a small project in both languages and compare the results, make sure to use all the resources <http://www.cpan.org/> of each language, as a language is far more than just it's syntax. Found in /usr/share/perl/5.38/pod/perlfaq2.pod What machines support Perl? Where do I get it? The standard release of Perl (the one maintained by the Perl development team) is distributed only in source code form. You can find the latest releases at <http://www.cpan.org/src/>. Perl builds and runs on a bewildering number of platforms. Virtually all known and current Unix derivatives are supported (perl's native platform), as are other systems like VMS, DOS, OS/2, Windows, QNX, BeOS, OS X, MPE/iX and the Amiga. Binary distributions for some proprietary platforms can be found <http://www.cpan.org/ports/> directory. Because these are not part of the standard distribution, they may and in fact do differ from the base perl port in a variety of ways. You'll have to check their respective release notes to see just what the differences are. These differences can be either positive (e.g. extensions for the features of the particular platform that are not supported in the source release of perl) or negative (e.g. might be based upon a less current source release of perl). I grabbed the sources and tried to compile but gdbm/dynamic loading/malloc/linking/... failed. How do I make it work? Read the INSTALL file, which is part of the source distribution. It describes in detail how to cope with most idiosyncrasies that the "Configure" script can't work around for any given system or architecture. Found in /usr/share/perl/5.38/pod/perlfaq3.pod 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 (in alphabetical order, not order of preference): Eclipse <http://e-p-i-c.sf.net/> The Eclipse Perl Integration Project integrates Perl editing/debugging with Eclipse. Enginsite <http://www.enginsite.com/> Perl Editor by EngInSite is a complete integrated development environment (IDE) for creating, testing, and debugging Perl scripts; the tool runs on Windows 9x/NT/2000/XP or later. IntelliJ IDEA <https://plugins.jetbrains.com/plugin/7796> Camelcade plugin provides Perl5 support in IntelliJ IDEA and other JetBrains IDEs. Kephra <http://kephra.sf.net> GUI editor written in Perl using wxWidgets and Scintilla with lots of smaller features. Aims for a UI based on Perl principles like TIMTOWTDI and "easy things should be easy, hard things should be possible". Komodo <http://www.ActiveState.com/Products/Komodo/> ActiveState's cross-platform (as of October 2004, that's Windows, Linux, and Solaris), multi-language IDE has Perl support, including a regular expression debugger and remote debugging. Notepad++ <http://notepad-plus.sourceforge.net/> 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. OptiPerl <http://www.optiperl.com/> OptiPerl is a Windows IDE with simulated CGI environment, including debugger and syntax-highlighting editor. Padre <http://padre.perlide.org/> Padre is cross-platform IDE for Perl written in Perl using wxWidgets to provide a native look and feel. It's open source under the Artistic License. It is one of the newer Perl IDEs. PerlBuilder <http://www.solutionsoft.com/perl.htm> PerlBuilder is an integrated development environment for Windows that supports Perl development. visiPerl+ <http://helpconsulting.net/visiperl/index.html> From Help Consulting, for Windows. Visual Perl <http://www.activestate.com/Products/Visual_Perl/> Visual Perl is a Visual Studio.NET plug-in from ActiveState. Zeus <http://www.zeusedit.com/lookmain.html> Zeus for Windows is another Win32 multi-language editor/IDE that comes with support for Perl. 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.barebones.com/products/bbedit/> ) or Alpha ( <http://www.his.com/~jguyer/Alpha/Alpha8.html> ). 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 Vim <http://www.vim.org/> Vile <http://invisible-island.net/vile/vile.html> The following are Win32 multilanguage editor/IDEs that support Perl: MultiEdit <http://www.MultiEdit.com/> SlickEdit <http://www.slickedit.com/> ConTEXT <http://www.contexteditor.org/> There is also a toyedit Text widget based editor written in Perl that is distributed with the Tk module on CPAN. The ptkdb ( <http://ptkdb.sourceforge.net/> ) 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://cygwin.com/> ) zsh <http://www.zsh.org/> Cygwin is covered by the GNU General Public License (but that shouldn't matter for Perl use). Cygwin contains (in addition to the shell) a comprehensive set of standard Unix toolkit utilities. BBEdit and TextWrangler are text editors for OS X that have a Perl sensitivity mode ( <http://www.barebones.com/> ). How can I use curses with Perl? 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/id/T/TO/TOMC/scripts/rep.gz> ; this program repeats a command and updates the screen as needed, rendering rep ps axu similar to top. How can I write a GUI (X, Tk, Gtk, etc.) in Perl? (contributed by Ben Morrow) There are a number of modules which let you write GUIs in Perl. Most GUI toolkits have a perl interface: an incomplete list follows. Tk This works under Unix and Windows, and the current version doesn't look half as bad under Windows as it used to. Some of the gui elements still don't 'feel' quite right, though. The interface is very natural and 'perlish', making it easy to use in small scripts that just need a simple gui. It hasn't been updated in a while. Wx This is a Perl binding for the cross-platform wxWidgets toolkit ( <http://www.wxwidgets.org> ). It works under Unix, Win32 and Mac OS X, using native widgets (Gtk under Unix). The interface follows the C++ interface closely, but the documentation is a little sparse for someone who doesn't know the library, mostly just referring you to the C++ documentation. Gtk and Gtk2 These are Perl bindings for the Gtk toolkit ( <http://www.gtk.org> ). The interface changed significantly between versions 1 and 2 so they have separate Perl modules. It runs under Unix, Win32 and Mac OS X (currently it requires an X server on Mac OS, but a 'native' port is underway), and the widgets look the same on every platform: i.e., they don't match the native widgets. As with Wx, the Perl bindings follow the C API closely, and the documentation requires you to read the C documentation to understand it. Win32::GUI This provides access to most of the Win32 GUI widgets from Perl. Obviously, it only runs under Win32, and uses native widgets. The Perl interface doesn't really follow the C interface: it's been made more Perlish, and the documentation is pretty good. More advanced stuff may require familiarity with the C Win32 APIs, or reference to MSDN. CamelBones CamelBones ( <http://camelbones.sourceforge.net> ) is a Perl interface to Mac OS X's Cocoa GUI toolkit, and as such can be used to produce native GUIs on Mac OS X. It's not on CPAN, as it requires frameworks that CPAN.pm doesn't know how to install, but installation is via the standard OSX package installer. The Perl API is, again, very close to the ObjC API it's wrapping, and the documentation just tells you how to translate from one to the other. Qt There is a Perl interface to TrollTech's Qt toolkit, but it does not appear to be maintained. Athena Sx is an interface to the Athena widget set which comes with X, but again it appears not to be much used nowadays. Is it safe to return a reference to local or lexical data? Yes. Perl's garbage collection system takes care of this so everything works out right. sub makeone { my @a = ( 1 .. 10 ); return \@a; } for ( 1 .. 10 ) { push @many, makeone(); } print $many[4][5], "\n"; print "@many\n"; Can I write useful Perl programs on the command line? Yes. Read perlrun for more information. Some examples follow. (These assume standard Unix shell quoting rules.) # sum first and last fields perl -lane 'print $F[0] + $F[-1]' * # identify text files perl -le 'for(@ARGV) {print if -f && -T _}' * # remove (most) comments from C program perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c # make file a month younger than today, defeating reaper daemons perl -e '$X=24*60*60; utime(time(),time() + 30 * $X,@ARGV)' * # find first unused uid perl -le '$i++ while getpwuid($i); print $i' # display reasonable manpath echo $PATH | perl -nl -072 -e ' s![^/+]*$!man!&&-d&&!$s{$_}++&&push@m,$_;END{print"@m"}' OK, the last one was actually an Obfuscated Perl Contest entry. :-) Where can I learn about linking C with Perl? If you want to call C from Perl, start with perlxstut, moving on to perlxs, xsubpp, and perlguts. If you want to call Perl from C, then read perlembed, perlcall, and perlguts. Don't forget that you can learn a lot from looking at how the authors of existing extension modules wrote their code and solved their problems. You might not need all the power of XS. The Inline::C module lets you put C code directly in your Perl source. It handles all the magic to make it work. You still have to learn at least some of the perl API but you won't have to deal with the complexity of the XS support files. When I tried to run my script, I got this message. What does it mean? A complete list of Perl's error messages and warnings with explanatory text can be found in perldiag. You can also use the splain program (distributed with Perl) to explain the error messages: perl program 2>diag.out splain [-v] [-p] diag.out or change your program to explain the messages for you: use diagnostics; or use diagnostics -verbose; Found in /usr/share/perl/5.38/pod/perlfaq4.pod Why doesn't & work the way I want it to? The behavior of binary arithmetic operators depends on whether they're used on numbers or strings. The operators treat a string as a series of bits and work with that (the string "3" is the bit pattern 00110011). The operators work with the binary form of a number (the number 3 is treated as the bit pattern 00000011). So, saying "11 & 3" performs the "and" operation on numbers (yielding 3). Saying "11" & "3" performs the "and" operation on strings (yielding "1"). Most problems with "&" and "|" arise because the programmer thinks they have a number but really it's a string or vice versa. To avoid this, stringify the arguments explicitly (using "" or qq()) or convert them to numbers explicitly (using "0+$arg"). The rest arise because the programmer says: if ("\020\020" & "\101\101") { # ... } but a string consisting of two null bytes (the result of "\020\020" & "\101\101") is not a false value in Perl. You need: if ( ("\020\020" & "\101\101") !~ /[^\000]/) { # ... } How can I take a string and turn it into epoch seconds? If it's a regular enough string that it always has the same format, you can split it up and pass the parts to "timelocal" in the standard Time::Local module. Otherwise, you should look into the Date::Calc, Date::Parse, and Date::Manip modules from CPAN. How can I count the number of occurrences of a substring within a string? There are a number of ways, with varying efficiency. If you want a count of a certain single character (X) within a string, you can use the "tr///" function like so: my $string = "ThisXlineXhasXsomeXx'sXinXit"; my $count = ($string =~ tr/X//); print "There are $count X characters in the string"; This is fine if you are just looking for a single character. However, if you are trying to count multiple character substrings within a larger string, "tr///" won't work. What you can do is wrap a while() loop around a global pattern match. For example, let's count negative integers: my $string = "-9 55 48 -2 23 -76 4 14 -44"; my $count = 0; while ($string =~ /-\d+/g) { $count++ } print "There are $count negative numbers in the string"; Another version uses a global match in list context, then assigns the result to a scalar, producing a count of the number of matches. my $count = () = $string =~ /-\d+/g; How do I capitalize all the words on one line? (contributed by brian d foy) Damian Conway's Text::Autoformat handles all of the thinking for you. use Text::Autoformat; my $x = "Dr. Strangelove or: How I Learned to Stop ". "Worrying and Love the Bomb"; print $x, "\n"; for my $style (qw( sentence title highlight )) { print autoformat($x, { case => $style }), "\n"; } How do you want to capitalize those words? FRED AND BARNEY'S LODGE # all uppercase Fred And Barney's Lodge # title case Fred and Barney's Lodge # highlight case It's not as easy a problem as it looks. How many words do you think are in there? Wait for it... wait for it.... If you answered 5 you're right. Perl words are groups of "\w+", but that's not what you want to capitalize. How is Perl supposed to know not to capitalize that "s" after the apostrophe? You could try a regular expression: $string =~ s/ ( (^\w) #at the beginning of the line | # or (\s\w) #preceded by whitespace ) /\U$1/xg; $string =~ s/([\w']+)/\u\L$1/g; Now, what if you don't want to capitalize that "and"? Just use Text::Autoformat and get on with the next problem. :) How can I split a [character]-delimited string except when inside [character]? Several modules can handle this sort of parsing--Text::Balanced, Text::CSV, Text::CSV_XS, and Text::ParseWords, among others. Take the example case of trying to split a string that is comma-separated into its different fields. You can't use "split(/,/)" because you shouldn't split if the comma is inside quotes. For example, take a data line like this: SAR001,"","Cimetrix, Inc","Bob Smith","CAM",N,8,1,0,7,"Error, Core Dumped" Due to the restriction of the quotes, this is a fairly complex problem. Thankfully, we have Jeffrey Friedl, author of *Mastering Regular Expressions*, to handle these for us. He suggests (assuming your string is contained in $text): my @new = (); push(@new, $+) while $text =~ m{ "([^\"\\]*(?:\\.[^\"\\]*)*)",? # groups the phrase inside the quotes | ([^,]+),? | , }gx; push(@new, undef) if substr($text,-1,1) eq ','; If you want to represent quotation marks inside a quotation-mark-delimited field, escape them with backslashes (eg, "like \"this\"". Alternatively, the Text::ParseWords module (part of the standard Perl distribution) lets you say: use Text::ParseWords; @new = quotewords(",", 0, $text); For parsing or generating CSV, though, using Text::CSV rather than implementing it yourself is highly recommended; you'll save yourself odd bugs popping up later by just using code which has already been tried and tested in production for years. How do I pad a string with blanks or pad a number with zeroes? In the following examples, $pad_len is the length to which you wish to pad the string, $text or $num contains the string to be padded, and $pad_char contains the padding character. You can use a single character string constant instead of the $pad_char variable if you know what it is in advance. And in the same way you can use an integer in place of $pad_len if you know the pad length in advance. The simplest method uses the "sprintf" function. It can pad on the left or right with blanks and on the left with zeroes and it will not truncate the result. The "pack" function can only pad strings on the right with blanks and it will truncate the result to a maximum length of $pad_len. # Left padding a string with blanks (no truncation): my $padded = sprintf("%${pad_len}s", $text); my $padded = sprintf("%*s", $pad_len, $text); # same thing # Right padding a string with blanks (no truncation): my $padded = sprintf("%-${pad_len}s", $text); my $padded = sprintf("%-*s", $pad_len, $text); # same thing # Left padding a number with 0 (no truncation): my $padded = sprintf("%0${pad_len}d", $num); my $padded = sprintf("%0*d", $pad_len, $num); # same thing # Right padding a string with blanks using pack (will truncate): my $padded = pack("A$pad_len",$text); If you need to pad with a character other than blank or zero you can use one of the following methods. They all generate a pad string with the "x" operator and combine that with $text. These methods do not truncate $text. Left and right padding with any character, creating a new string: my $padded = $pad_char x ( $pad_len - length( $text ) ) . $text; my $padded = $text . $pad_char x ( $pad_len - length( $text ) ); Left and right padding with any character, modifying $text directly: substr( $text, 0, 0 ) = $pad_char x ( $pad_len - length( $text ) ); $text .= $pad_char x ( $pad_len - length( $text ) ); What's wrong with always quoting "$vars"? The problem is that those double-quotes force stringification--coercing numbers and references into strings--even when you don't want them to be strings. Think of it this way: double-quote expansion is used to produce new strings. If you already have a string, why do you need more? If you get used to writing odd things like these: print "$var"; # BAD my $new = "$old"; # BAD somefunc("$var"); # BAD You'll be in trouble. Those should (in 99.8% of the cases) be the simpler and more direct: print $var; my $new = $old; somefunc($var); Otherwise, besides slowing you down, you're going to break code when the thing in the scalar is actually neither a string nor a number, but a reference: func(\@array); sub func { my $aref = shift; my $oref = "$aref"; # WRONG } You can also get into subtle problems on those few operations in Perl that actually do care about the difference between a string and a number, such as the magical "++" autoincrement operator or the syscall() function. Stringification also destroys arrays. my @lines = `command`; print "@lines"; # WRONG - extra blanks print @lines; # right How do I find the first array element for which a condition is true? To find the first array element which satisfies a condition, you can use the first() function in the List::Util module, which comes with Perl 5.8. This example finds the first element that contains "Perl". use List::Util qw(first); my $element = first { /Perl/ } @array; If you cannot use List::Util, you can make your own loop to do the same thing. Once you find the element, you stop the loop with last. my $found; foreach ( @array ) { if( /Perl/ ) { $found = $_; last } } If you want the array index, use the firstidx() function from "List::MoreUtils": use List::MoreUtils qw(firstidx); my $index = firstidx { /Perl/ } @array; Or write it yourself, iterating through the indices and checking the array element at each index until you find one that satisfies the condition: my( $found, $index ) = ( undef, -1 ); for( $i = 0; $i < @array; $i++ ) { if( $array[$i] =~ /Perl/ ) { $found = $array[$i]; $index = $i; last; } } How do I manipulate arrays of bits? Use pack() and unpack(), or else vec() and the bitwise operations. For example, you don't have to store individual bits in an array (which would mean that you're wasting a lot of space). To convert an array of bits to a string, use vec() to set the right bits. This sets $vec to have bit N set only if $ints[N] was set: my @ints = (...); # array of bits, e.g. ( 1, 0, 0, 1, 1, 0 ... ) my $vec = ''; foreach( 0 .. $#ints ) { vec($vec,$_,1) = 1 if $ints[$_]; } The string $vec only takes up as many bits as it needs. For instance, if you had 16 entries in @ints, $vec only needs two bytes to store them (not counting the scalar variable overhead). Here's how, given a vector in $vec, you can get those bits into your @ints array: sub bitvec_to_list { my $vec = shift; my @ints; # Find null-byte density then select best algorithm if ($vec =~ tr/\0// / length $vec > 0.95) { use integer; my $i; # This method is faster with mostly null-bytes while($vec =~ /[^\0]/g ) { $i = -9 + 8 * pos $vec; push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); push @ints, $i if vec($vec, ++$i, 1); } } else { # This method is a fast general algorithm use integer; my $bits = unpack "b*", $vec; push @ints, 0 if $bits =~ s/^(\d)// && $1; push @ints, pos $bits while($bits =~ /1/g); } return \@ints; } This method gets faster the more sparse the bit vector is. (Courtesy of Tim Bunce and Winfried Koenig.) You can make the while loop a lot shorter with this suggestion from Benjamin Goldberg: while($vec =~ /[^\0]+/g ) { push @ints, grep vec($vec, $_, 1), $-[0] * 8 .. $+[0] * 8; } Or use the CPAN module Bit::Vector: my $vector = Bit::Vector->new($num_of_bits); $vector->Index_List_Store(@ints); my @ints = $vector->Index_List_Read(); Bit::Vector provides efficient methods for bit vector, sets of small integers and "big int" math. Here's a more extensive illustration using vec(): # vec demo my $vector = "\xff\x0f\xef\xfe"; print "Ilya's string \\xff\\x0f\\xef\\xfe represents the number ", unpack("N", $vector), "\n"; my $is_set = vec($vector, 23, 1); print "Its 23rd bit is ", $is_set ? "set" : "clear", ".\n"; pvec($vector); set_vec(1,1,1); set_vec(3,1,1); set_vec(23,1,1); set_vec(3,1,3); set_vec(3,2,3); set_vec(3,4,3); set_vec(3,4,7); set_vec(3,8,3); set_vec(3,8,7); set_vec(0,32,17); set_vec(1,32,17); sub set_vec { my ($offset, $width, $value) = @_; my $vector = ''; vec($vector, $offset, $width) = $value; print "offset=$offset width=$width value=$value\n"; pvec($vector); } sub pvec { my $vector = shift; my $bits = unpack("b*", $vector); my $i = 0; my $BASE = 8; print "vector length in bytes: ", length($vector), "\n"; @bytes = unpack("A8" x length($vector), $bits); print "bits are: @bytes\n\n"; } What happens if I add or remove keys from a hash while iterating over it? (contributed by brian d foy) The easy answer is "Don't do that!" If you iterate through the hash with each(), you can delete the key most recently returned without worrying about it. If you delete or add other keys, the iterator may skip or double up on them since perl may rearrange the hash table. See the entry for each() in perlfunc. What's the difference between "delete" and "undef" with hashes? Hashes contain pairs of scalars: the first is the key, the second is the value. The key will be coerced to a string, although the value can be any kind of scalar: string, number, or reference. If a key $key is present in %hash, exists($hash{$key}) will return true. The value for a given key can be "undef", in which case $hash{$key} will be "undef" while "exists $hash{$key}" will return true. This corresponds to ($key, "undef") being in the hash. Pictures help... Here's the %hash table: keys values +------+------+ | a | 3 | | x | 7 | | d | 0 | | e | 2 | +------+------+ And these conditions hold $hash{'a'} is true $hash{'d'} is false defined $hash{'d'} is true defined $hash{'a'} is true exists $hash{'a'} is true (Perl 5 only) grep ($_ eq 'a', keys %hash) is true If you now say undef $hash{'a'} your table now reads: keys values +------+------+ | a | undef| | x | 7 | | d | 0 | | e | 2 | +------+------+ and these conditions now hold; changes in caps: $hash{'a'} is FALSE $hash{'d'} is false defined $hash{'d'} is true defined $hash{'a'} is FALSE exists $hash{'a'} is true (Perl 5 only) grep ($_ eq 'a', keys %hash) is true Notice the last two: you have an undef value, but a defined key! Now, consider this: delete $hash{'a'} your table now reads: keys values +------+------+ | x | 7 | | d | 0 | | e | 2 | +------+------+ and these conditions now hold; changes in caps: $hash{'a'} is false $hash{'d'} is false defined $hash{'d'} is true defined $hash{'a'} is false exists $hash{'a'} is FALSE (Perl 5 only) grep ($_ eq 'a', keys %hash) is FALSE See, the whole entry is gone! How can I make my hash remember the order I put elements into it? Use the Tie::IxHash from CPAN. use Tie::IxHash; tie my %myhash, 'Tie::IxHash'; for (my $i=0; $i<20; $i++) { $myhash{$i} = 2*$i; } my @keys = keys %myhash; # @keys = (0,1,2,3,...) Why does passing a subroutine an undefined element in a hash create it? (contributed by brian d foy) Are you using a really old version of Perl? Normally, accessing a hash key's value for a nonexistent key will *not* create the key. my %hash = (); my $value = $hash{ 'foo' }; print "This won't print\n" if exists $hash{ 'foo' }; Passing $hash{ 'foo' } to a subroutine used to be a special case, though. Since you could assign directly to $_[0], Perl had to be ready to make that assignment so it created the hash key ahead of time: my_sub( $hash{ 'foo' } ); print "This will print before 5.004\n" if exists $hash{ 'foo' }; sub my_sub { # $_[0] = 'bar'; # create hash key in case you do this 1; } Since Perl 5.004, however, this situation is a special case and Perl creates the hash key only when you make the assignment: my_sub( $hash{ 'foo' } ); print "This will print, even after 5.004\n" if exists $hash{ 'foo' }; sub my_sub { $_[0] = 'bar'; } However, if you want the old behavior (and think carefully about that because it's a weird side effect), you can pass a hash slice instead. Perl 5.004 didn't make this a special case: my_sub( @hash{ qw/foo/ } ); How can I prevent addition of unwanted keys into a hash? Since version 5.8.0, hashes can be *restricted* to a fixed number of given keys. Methods for creating and dealing with restricted hashes are exported by the Hash::Util module. How do I verify a credit card checksum? Get the Business::CreditCard module from CPAN. Found in /usr/share/perl/5.38/pod/perlfaq5.pod How can I use Perl's "-i" option from within a program? "-i" sets the value of Perl's $^I variable, which in turn affects the behavior of "<>"; see perlrun for more details. By modifying the appropriate variables directly, you can get the same behavior within a larger program. For example: # ... { local($^I, @ARGV) = ('.orig', glob("*.c")); while (<>) { if ($. == 1) { print "This line should appear at the top of each file\n"; } s/\b(p)earl\b/${1}erl/i; # Correct typos, preserving case print; close ARGV if eof; # Reset $. } } # $^I and @ARGV return to their old values here This block modifies all the ".c" files in the current directory, leaving a backup of the original data from each file in a new ".c.orig" file. How can I set up a footer format to be used with write()? There's no builtin way to do this, but perlform has a couple of techniques to make it possible for the intrepid hacker. How can I write() into a string? (contributed by brian d foy) If you want to "write" into a string, you just have to <open> a filehandle to a string, which Perl has been able to do since Perl 5.6: open FH, '>', \my $string; write( FH ); Since you want to be a good programmer, you probably want to use a lexical filehandle, even though formats are designed to work with bareword filehandles since the default format names take the filehandle name. However, you can control this with some Perl special per-filehandle variables: $^, which names the top-of-page format, and $~ which shows the line format. You have to change the default filehandle to set these variables: open my($fh), '>', \my $string; { # set per-filehandle variables my $old_fh = select( $fh ); $~ = 'ANIMAL'; $^ = 'ANIMAL_TOP'; select( $old_fh ); } format ANIMAL_TOP = ID Type Name . format ANIMAL = @## @<<< @<<<<<<<<<<<<<< $id, $type, $name . Although write can work with lexical or package variables, whatever variables you use have to scope in the format. That most likely means you'll want to localize some package variables: { local( $id, $type, $name ) = qw( 12 cat Buster ); write( $fh ); } print $string; There are also some tricks that you can play with "formline" and the accumulator variable $^A, but you lose a lot of the value of formats since "formline" won't handle paging and so on. You end up reimplementing formats when you use them. How can I output my numbers with commas added? (contributed by brian d foy and Benjamin Goldberg) You can use Number::Format to separate places in a number. It handles locale information for those of you who want to insert full stops instead (or anything else that they want to use, really). This subroutine will add commas to your number: sub commify { local $_ = shift; 1 while s/^([-+]?\d+)(\d{3})/$1,$2/; return $_; } This regex from Benjamin Goldberg will add commas to numbers: s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g; It is easier to see with comments: s/( ^[-+]? # beginning of number. \d+? # first digits before first comma (?= # followed by, (but not included in the match) : (?>(?:\d{3})+) # some positive multiple of three digits. (?!\d) # an *exact* multiple, not x * 3 + 1 or whatever. ) | # or: \G\d{3} # after the last group, get three digits (?=\d) # but they have to have more digits after them. )/$1,/xg; How come when I open a file read-write it wipes it out? Because you're using something like this, which truncates the file *then* gives you read-write access: open my $fh, '+>', '/path/name'; # WRONG (almost always) Whoops. You should instead use this, which will fail if the file doesn't exist: open my $fh, '+<', '/path/name'; # open for update Using ">" always clobbers or creates. Using "<" never does either. The "+" doesn't change this. Here are examples of many kinds of file opens. Those using "sysopen" all assume that you've pulled in the constants from Fcntl: use Fcntl; To open file for reading: open my $fh, '<', $path or die $!; sysopen my $fh, $path, O_RDONLY or die $!; To open file for writing, create new file if needed or else truncate old file: open my $fh, '>', $path or die $!; sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT or die $!; sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666 or die $!; To open file for writing, create new file, file must not exist: sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT or die $!; sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT, 0666 or die $!; To open file for appending, create if necessary: open my $fh, '>>', $path or die $!; sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT or die $!; sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT, 0666 or die $!; To open file for appending, file must exist: sysopen my $fh, $path, O_WRONLY|O_APPEND or die $!; To open file for update, file must exist: open my $fh, '+<', $path or die $!; sysopen my $fh, $path, O_RDWR or die $!; To open file for update, create file if necessary: sysopen my $fh, $path, O_RDWR|O_CREAT or die $!; sysopen my $fh, $path, O_RDWR|O_CREAT, 0666 or die $!; To open file for update, file must not exist: sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT or die $!; sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT, 0666 or die $!; To open a file without blocking, creating if necessary: sysopen my $fh, '/foo/somefile', O_WRONLY|O_NDELAY|O_CREAT or die "can't open /foo/somefile: $!": Be warned that neither creation nor deletion of files is guaranteed to be an atomic operation over NFS. That is, two processes might both successfully create or unlink the same file! Therefore O_EXCL isn't as exclusive as you might wish. See also perlopentut. How can I open a file named with a leading ">" or trailing blanks? (contributed by Brian McCauley) The special two-argument form of Perl's open() function ignores trailing blanks in filenames and infers the mode from certain leading characters (or a trailing "|"). In older versions of Perl this was the only version of open() and so it is prevalent in old code and books. Unless you have a particular reason to use the two-argument form you should use the three-argument form of open() which does not treat any characters in the filename as special. open my $fh, "<", " file "; # filename is " file " open my $fh, ">", ">file"; # filename is ">file" How can I tell whether there's a character waiting on a filehandle? The very first thing you should do is look into getting the Term::ReadKey extension from CPAN. As we mentioned earlier, it now even has limited support for non-portable (read: not open systems, closed, proprietary, not POSIX, not Unix, etc.) systems. You should also check out the Frequently Asked Questions list in comp.unix.* for things like this: the answer is essentially the same. It's very system-dependent. Here's one solution that works on BSD systems: sub key_ready { my($rin, $nfd); vec($rin, fileno(STDIN), 1) = 1; return $nfd = select($rin,undef,undef,0); } If you want to find out how many characters are waiting, there's also the FIONREAD ioctl call to be looked at. The *h2ph* tool that comes with Perl tries to convert C include files to Perl code, which can be "require"d. FIONREAD ends up defined as a function in the *sys/ioctl.ph* file: require './sys/ioctl.ph'; $size = pack("L", 0); ioctl(FH, FIONREAD(), $size) or die "Couldn't call ioctl: $!\n"; $size = unpack("L", $size); If *h2ph* wasn't installed or doesn't work for you, you can *grep* the include files by hand: % grep FIONREAD /usr/include/*/* /usr/include/asm/ioctls.h:#define FIONREAD 0x541B Or write a small C program using the editor of champions: % cat > fionread.c #include <sys/ioctl.h> main() { printf("%#08x\n", FIONREAD); } ^D % cc -o fionread fionread.c % ./fionread 0x4004667f And then hard-code it, leaving porting as an exercise to your successor. $FIONREAD = 0x4004667f; # XXX: opsys dependent $size = pack("L", 0); ioctl(FH, $FIONREAD, $size) or die "Couldn't call ioctl: $!\n"; $size = unpack("L", $size); FIONREAD requires a filehandle connected to a stream, meaning that sockets, pipes, and tty devices work, but *not* files. Found in /usr/share/perl/5.38/pod/perlfaq6.pod How can I hope to use regular expressions without creating illegible and unmaintainable code? Three techniques can make regular expressions maintainable and understandable. Comments Outside the Regex Describe what you're doing and how you're doing it, using normal Perl comments. # turn the line into the first word, a colon, and the # number of characters on the rest of the line s/^(\w+)(.*)/ lc($1) . ":" . length($2) /meg; Comments Inside the Regex The "/x" modifier causes whitespace to be ignored in a regex pattern (except in a character class and a few other places), and also allows you to use normal comments there, too. As you can imagine, whitespace and comments help a lot. "/x" lets you turn this: s{<(?:[^>'"]*|".*?"|'.*?')+>}{}gs; into this: s{ < # opening angle bracket (?: # Non-backreffing grouping paren [^>'"] * # 0 or more things that are neither > nor ' nor " | # or else ".*?" # a section between double quotes (stingy match) | # or else '.*?' # a section between single quotes (stingy match) ) + # all occurring one or more times > # closing angle bracket }{}gsx; # replace with nothing, i.e. delete It's still not quite so clear as prose, but it is very useful for describing the meaning of each part of the pattern. Different Delimiters While we normally think of patterns as being delimited with "/" characters, they can be delimited by almost any character. perlre describes this. For example, the "s///" above uses braces as delimiters. Selecting another delimiter can avoid quoting the delimiter within the pattern: s/\/usr\/local/\/usr\/share/g; # bad delimiter choice s#/usr/local#/usr/share#g; # better Using logically paired delimiters can be even more readable: s{/usr/local/}{/usr/share}g; # better still How do I match XML, HTML, or other nasty, ugly things with a regex? Do not use regexes. Use a module and forget about the regular expressions. The XML::LibXML, HTML::TokeParser and HTML::TreeBuilder modules are good starts, although each namespace has other parsing modules specialized for certain tasks and different ways of doing it. Start at CPAN Search ( <http://metacpan.org/> ) and wonder at all the work people have done for you already! :) I put a regular expression into $/ but it didn't work. What's wrong? $/ has to be a string. You can use these examples if you really need to do this. If you have File::Stream, this is easy. use File::Stream; my $stream = File::Stream->new( $filehandle, separator => qr/\s*,\s*/, ); print "$_\n" while <$stream>; If you don't have File::Stream, you have to do a little more work. You can use the four-argument form of sysread to continually add to a buffer. After you add to the buffer, you check if you have a complete line (using your regular expression). local $_ = ""; while( sysread FH, $_, 8192, length ) { while( s/^((?s).*?)your_pattern// ) { my $record = $1; # do stuff here. } } You can do the same thing with foreach and a match using the c flag and the \G anchor, if you do not mind your entire file being in memory at the end. local $_ = ""; while( sysread FH, $_, 8192, length ) { foreach my $record ( m/\G((?s).*?)your_pattern/gc ) { # do stuff here. } substr( $_, 0, pos ) = "" if pos; } How do I substitute case-insensitively on the LHS while preserving case on the RHS? Here's a lovely Perlish solution by Larry Rosler. It exploits properties of bitwise xor on ASCII strings. $_= "this is a TEsT case"; $old = 'test'; $new = 'success'; s{(\Q$old\E)} { uc $new | (uc $1 ^ $1) . (uc(substr $1, -1) ^ substr $1, -1) x (length($new) - length $1) }egi; print; And here it is as a subroutine, modeled after the above: sub preserve_case { my ($old, $new) = @_; my $mask = uc $old ^ $old; uc $new | $mask . substr($mask, -1) x (length($new) - length($old)) } $string = "this is a TEsT case"; $string =~ s/(test)/preserve_case($1, "success")/egi; print "$string\n"; This prints: this is a SUcCESS case As an alternative, to keep the case of the replacement word if it is longer than the original, you can use this code, by Jeff Pinyan: sub preserve_case { my ($from, $to) = @_; my ($lf, $lt) = map length, @_; if ($lt < $lf) { $from = substr $from, 0, $lt } else { $from .= substr $to, $lf } return uc $to | ($from ^ uc $from); } This changes the sentence to "this is a SUcCess case." Just to show that C programmers can write C in any programming language, if you prefer a more C-like solution, the following script makes the substitution have the same case, letter by letter, as the original. (It also happens to run about 240% slower than the Perlish solution runs.) If the substitution has more characters than the string being substituted, the case of the last character is used for the rest of the substitution. # Original by Nathan Torkington, massaged by Jeffrey Friedl # sub preserve_case { my ($old, $new) = @_; my $state = 0; # 0 = no change; 1 = lc; 2 = uc my ($i, $oldlen, $newlen, $c) = (0, length($old), length($new)); my $len = $oldlen < $newlen ? $oldlen : $newlen; for ($i = 0; $i < $len; $i++) { if ($c = substr($old, $i, 1), $c =~ /[\W\d_]/) { $state = 0; } elsif (lc $c eq $c) { substr($new, $i, 1) = lc(substr($new, $i, 1)); $state = 1; } else { substr($new, $i, 1) = uc(substr($new, $i, 1)); $state = 2; } } # finish up with any remaining new (for when new is longer than old) if ($newlen > $oldlen) { if ($state == 1) { substr($new, $oldlen) = lc(substr($new, $oldlen)); } elsif ($state == 2) { substr($new, $oldlen) = uc(substr($new, $oldlen)); } } return $new; } What does it mean that regexes are greedy? How can I get around it? Most people mean that greedy regexes match as much as they can. Technically speaking, it's actually the quantifiers ("?", "*", "+", "{}") that are greedy rather than the whole pattern; Perl prefers local greed and immediate gratification to overall greed. To get non-greedy versions of the same quantifiers, use ("??", "*?", "+?", "{}?"). An example: my $s1 = my $s2 = "I am very very cold"; $s1 =~ s/ve.*y //; # I am cold $s2 =~ s/ve.*?y //; # I am very cold Notice how the second substitution stopped matching as soon as it encountered "y ". The "*?" quantifier effectively tells the regular expression engine to find a match as quickly as possible and pass control on to whatever is next in line, as you would if you were playing hot potato. Why don't word-boundary searches with "\b" work for me? (contributed by brian d foy) Ensure that you know what \b really does: it's the boundary between a word character, \w, and something that isn't a word character. That thing that isn't a word character might be \W, but it can also be the start or end of the string. It's not (not!) the boundary between whitespace and non-whitespace, and it's not the stuff between words we use to create sentences. In regex speak, a word boundary (\b) is a "zero width assertion", meaning that it doesn't represent a character in the string, but a condition at a certain position. For the regular expression, /\bPerl\b/, there has to be a word boundary before the "P" and after the "l". As long as something other than a word character precedes the "P" and succeeds the "l", the pattern will match. These strings match /\bPerl\b/. "Perl" # no word char before "P" or after "l" "Perl " # same as previous (space is not a word char) "'Perl'" # the "'" char is not a word char "Perl's" # no word char before "P", non-word char after "l" These strings do not match /\bPerl\b/. "Perl_" # "_" is a word char! "Perler" # no word char before "P", but one after "l" You don't have to use \b to match words though. You can look for non-word characters surrounded by word characters. These strings match the pattern /\b'\b/. "don't" # the "'" char is surrounded by "n" and "t" "qep'a'" # the "'" char is surrounded by "p" and "a" These strings do not match /\b'\b/. "foo'" # there is no word char after non-word "'" You can also use the complement of \b, \B, to specify that there should not be a word boundary. In the pattern /\Bam\B/, there must be a word character before the "a" and after the "m". These patterns match /\Bam\B/: "llama" # "am" surrounded by word chars "Samuel" # same These strings do not match /\Bam\B/ "Sam" # no word boundary before "a", but one after "m" "I am Sam" # "am" surrounded by non-word chars What's wrong with using grep in a void context? The problem is that grep builds a return list, regardless of the context. This means you're making Perl go to the trouble of building a list that you then just throw away. If the list is large, you waste both time and space. If your intent is to iterate over the list, then use a for loop for this purpose. In perls older than 5.8.1, map suffers from this problem as well. But since 5.8.1, this has been fixed, and map is context aware - in void context, no lists are constructed. How can I match strings with multibyte characters? Starting from Perl 5.6 Perl has had some level of multibyte character support. Perl 5.8 or later is recommended. Supported multibyte character repertoires include Unicode, and legacy encodings through the Encode module. See perluniintro, perlunicode, and Encode. If you are stuck with older Perls, you can do Unicode with the Unicode::String module, and character conversions using the Unicode::Map8 and Unicode::Map modules. If you are using Japanese encodings, you might try using the jperl 5.005_03. Finally, the following set of approaches was offered by Jeffrey Friedl, whose article in issue #5 of The Perl Journal talks about this very matter. Let's suppose you have some weird Martian encoding where pairs of ASCII uppercase letters encode single Martian letters (i.e. the two bytes "CV" make a single Martian letter, as do the two bytes "SG", "VS", "XX", etc.). Other bytes represent single characters, just like ASCII. So, the string of Martian "I am CVSGXX!" uses 12 bytes to encode the nine characters 'I', ' ', 'a', 'm', ' ', 'CV', 'SG', 'XX', '!'. Now, say you want to search for the single character "/GX/". Perl doesn't know about Martian, so it'll find the two bytes "GX" in the "I am CVSGXX!" string, even though that character isn't there: it just looks like it is because "SG" is next to "XX", but there's no real "GX". This is a big problem. Here are a few ways, all painful, to deal with it: # Make sure adjacent "martian" bytes are no longer adjacent. $martian =~ s/([A-Z][A-Z])/ $1 /g; print "found GX!\n" if $martian =~ /GX/; Or like this: my @chars = $martian =~ m/([A-Z][A-Z]|[^A-Z])/g; # above is conceptually similar to: my @chars = $text =~ m/(.)/g; # foreach my $char (@chars) { print "found GX!\n", last if $char eq 'GX'; } Or like this: while ($martian =~ m/\G([A-Z][A-Z]|.)/gs) { # \G probably unneeded if ($1 eq 'GX') { print "found GX!\n"; last; } } Here's another, slightly less painful, way to do it from Benjamin Goldberg, who uses a zero-width negative look-behind assertion. print "found GX!\n" if $martian =~ m/ (?<![A-Z]) (?:[A-Z][A-Z])*? GX /x; This succeeds if the "martian" character GX is in the string, and fails otherwise. If you don't like using (?<!), a zero-width negative look-behind assertion, you can replace (?<![A-Z]) with (?:^|[^A-Z]). It does have the drawback of putting the wrong thing in $-[0] and $+[0], but this usually can be worked around. Found in /usr/share/perl/5.38/pod/perlfaq7.pod What is variable suicide and how can I prevent it? This problem was fixed in perl 5.004_05, so preventing it means upgrading your version of perl. ;) Variable suicide is when you (temporarily or permanently) lose the value of a variable. It is caused by scoping through my() and local() interacting with either closures or aliased foreach() iterator variables and subroutine arguments. It used to be easy to inadvertently lose a variable's value this way, but now it's much harder. Take this code: my $f = 'foo'; sub T { while ($i++ < 3) { my $f = $f; $f .= "bar"; print $f, "\n" } } T; print "Finally $f\n"; If you are experiencing variable suicide, that "my $f" in the subroutine doesn't pick up a fresh copy of the $f whose value is 'foo'. The output shows that inside the subroutine the value of $f leaks through when it shouldn't, as in this output: foobar foobarbar foobarbarbar Finally foo The $f that has "bar" added to it three times should be a new $f "my $f" should create a new lexical variable each time through the loop. The expected output is: foobar foobar foobar Finally foo How do I create a switch or case statement? There is a given/when statement in Perl, but it is experimental and likely to change in future. See perlsyn for more details. The general answer is to use a CPAN module such as Switch::Plain: use Switch::Plain; sswitch($variable_holding_a_string) { case 'first': { } case 'second': { } default: { } } or for more complicated comparisons, "if-elsif-else": for ($variable_to_test) { if (/pat1/) { } # do something elsif (/pat2/) { } # do something else elsif (/pat3/) { } # do something else else { } # default } Here's a simple example of a switch based on pattern matching, lined up in a way to make it look more like a switch statement. We'll do a multiway conditional based on the type of reference stored in $whatchamacallit: SWITCH: for (ref $whatchamacallit) { /^$/ && die "not a reference"; /SCALAR/ && do { print_scalar($$ref); last SWITCH; }; /ARRAY/ && do { print_array(@$ref); last SWITCH; }; /HASH/ && do { print_hash(%$ref); last SWITCH; }; /CODE/ && do { warn "can't print function ref"; last SWITCH; }; # DEFAULT warn "User defined type skipped"; } See perlsyn for other examples in this style. Sometimes you should change the positions of the constant and the variable. For example, let's say you wanted to test which of many answers you were given, but in a case-insensitive way that also allows abbreviations. You can use the following technique if the strings all start with different characters or if you want to arrange the matches so that one takes precedence over another, as "SEND" has precedence over "STOP" here: chomp($answer = <>); if ("SEND" =~ /^\Q$answer/i) { print "Action is send\n" } elsif ("STOP" =~ /^\Q$answer/i) { print "Action is stop\n" } elsif ("ABORT" =~ /^\Q$answer/i) { print "Action is abort\n" } elsif ("LIST" =~ /^\Q$answer/i) { print "Action is list\n" } elsif ("EDIT" =~ /^\Q$answer/i) { print "Action is edit\n" } A totally different approach is to create a hash of function references. my %commands = ( "happy" => \&joy, "sad", => \&sullen, "done" => sub { die "See ya!" }, "mad" => \&angry, ); print "How are you? "; chomp($string = <STDIN>); if ($commands{$string}) { $commands{$string}->(); } else { print "No such command: $string\n"; } Starting from Perl 5.8, a source filter module, "Switch", can also be used to get switch and case. Its use is now discouraged, because it's not fully compatible with the native switch of Perl 5.10, and because, as it's implemented as a source filter, it doesn't always work as intended when complex syntax is involved. Found in /usr/share/perl/5.38/pod/perlfaq8.pod How do I do fancy stuff with the keyboard/screen/mouse? How you access/control keyboards, screens, and pointing devices ("mice") is system-dependent. Try the following modules: Keyboard Term::Cap Standard perl distribution Term::ReadKey CPAN Term::ReadLine::Gnu CPAN Term::ReadLine::Perl CPAN Term::Screen CPAN Screen Term::Cap Standard perl distribution Curses CPAN Term::ANSIColor CPAN Mouse Tk CPAN Wx CPAN Gtk2 CPAN Qt4 kdebindings4 package Some of these specific cases are shown as examples in other answers in this section of the perlfaq. How do I read just one key without waiting for a return key? Controlling input buffering is a remarkably system-dependent matter. On many systems, you can just use the stty command as shown in "getc" in perlfunc, but as you see, that's already getting you into portability snags. open(TTY, "+</dev/tty") or die "no tty: $!"; system "stty cbreak </dev/tty >/dev/tty 2>&1"; $key = getc(TTY); # perhaps this works # OR ELSE sysread(TTY, $key, 1); # probably this does system "stty -cbreak </dev/tty >/dev/tty 2>&1"; The Term::ReadKey module from CPAN offers an easy-to-use interface that should be more efficient than shelling out to stty for each key. It even includes limited support for Windows. use Term::ReadKey; ReadMode('cbreak'); $key = ReadKey(0); ReadMode('normal'); However, using the code requires that you have a working C compiler and can use it to build and install a CPAN module. Here's a solution using the standard POSIX module, which is already on your system (assuming your system supports POSIX). use HotKey; $key = readkey(); And here's the "HotKey" module, which hides the somewhat mystifying calls to manipulate the POSIX termios structures. # HotKey.pm package HotKey; use strict; use warnings; use parent 'Exporter'; our @EXPORT = qw(cbreak cooked readkey); use POSIX qw(:termios_h); my ($term, $oterm, $echo, $noecho, $fd_stdin); $fd_stdin = fileno(STDIN); $term = POSIX::Termios->new(); $term->getattr($fd_stdin); $oterm = $term->getlflag(); $echo = ECHO | ECHOK | ICANON; $noecho = $oterm & ~$echo; sub cbreak { $term->setlflag($noecho); # ok, so i don't want echo either $term->setcc(VTIME, 1); $term->setattr($fd_stdin, TCSANOW); } sub cooked { $term->setlflag($oterm); $term->setcc(VTIME, 0); $term->setattr($fd_stdin, TCSANOW); } sub readkey { my $key = ''; cbreak(); sysread(STDIN, $key, 1); cooked(); return $key; } END { cooked() } 1; How do I read and write the serial port? This depends on which operating system your program is running on. In the case of Unix, the serial ports will be accessible through files in "/dev"; on other systems, device names will doubtless differ. Several problem areas common to all device interaction are the following: lockfiles Your system may use lockfiles to control multiple access. Make sure you follow the correct protocol. Unpredictable behavior can result from multiple processes reading from one device. open mode If you expect to use both read and write operations on the device, you'll have to open it for update (see "open" in perlfunc for details). You may wish to open it without running the risk of blocking by using sysopen() and "O_RDWR|O_NDELAY|O_NOCTTY" from the Fcntl module (part of the standard perl distribution). See "sysopen" in perlfunc for more on this approach. end of line Some devices will be expecting a "\r" at the end of each line rather than a "\n". In some ports of perl, "\r" and "\n" are different from their usual (Unix) ASCII values of "\015" and "\012". You may have to give the numeric values you want directly, using octal ("\015"), hex ("0x0D"), or as a control-character specification ("\cM"). print DEV "atv1\012"; # wrong, for some devices print DEV "atv1\015"; # right, for some devices Even though with normal text files a "\n" will do the trick, there is still no unified scheme for terminating a line that is portable between Unix, DOS/Win, and Macintosh, except to terminate *ALL* line ends with "\015\012", and strip what you don't need from the output. This applies especially to socket I/O and autoflushing, discussed next. flushing output If you expect characters to get to your device when you print() them, you'll want to autoflush that filehandle. You can use select() and the $| variable to control autoflushing (see "$|" in perlvar and "select" in perlfunc, or perlfaq5, "How do I flush/unbuffer an output filehandle? Why must I do this?"): my $old_handle = select($dev_fh); $| = 1; select($old_handle); You'll also see code that does this without a temporary variable, as in select((select($deb_handle), $| = 1)[0]); Or if you don't mind pulling in a few thousand lines of code just because you're afraid of a little $| variable: use IO::Handle; $dev_fh->autoflush(1); As mentioned in the previous item, this still doesn't work when using socket I/O between Unix and Macintosh. You'll need to hard code your line terminators, in that case. non-blocking input If you are doing a blocking read() or sysread(), you'll have to arrange for an alarm handler to provide a timeout (see "alarm" in perlfunc). If you have a non-blocking open, you'll likely have a non-blocking read, which means you may have to use a 4-arg select() to determine whether I/O is ready on that device (see "select" in perlfunc. While trying to read from his caller-id box, the notorious Jamie Zawinski "<jwz AT netscape.com>", after much gnashing of teeth and fighting with "sysread", "sysopen", POSIX's "tcgetattr" business, and various other functions that go bump in the night, finally came up with this: sub open_modem { use IPC::Open2; my $stty = `/bin/stty -g`; open2( \*MODEM_IN, \*MODEM_OUT, "cu -l$modem_device -s2400 2>&1"); # starting cu hoses /dev/tty's stty settings, even when it has # been opened on a pipe... system("/bin/stty $stty"); $_ = <MODEM_IN>; chomp; if ( !m/^Connected/ ) { print STDERR "$0: cu printed `$_' instead of `Connected'\n"; } } How can I do an atexit() or setjmp()/longjmp()? (Exception handling) You can use the "END" block to simulate atexit(). Each package's "END" block is called when the program or thread ends. See the perlmod manpage for more details about "END" blocks. For example, you can use this to make sure your filter program managed to finish its output without filling up the disk: END { close(STDOUT) || die "stdout close failed: $!"; } The "END" block isn't called when untrapped signals kill the program, though, so if you use "END" blocks you should also use use sigtrap qw(die normal-signals); Perl's exception-handling mechanism is its eval() operator. You can use eval() as "setjmp" and die() as "longjmp". For details of this, see the section on signals, especially the time-out handler for a blocking flock() in "Signals" in perlipc or the section on "Signals" in *Programming Perl*. If exception handling is all you're interested in, use one of the many CPAN modules that handle exceptions, such as Try::Tiny. If you want the atexit() syntax (and an rmexit() as well), try the "AtExit" module available from CPAN. Why can't I get the output of a command with system()? You're confusing the purpose of system() and backticks (``). system() runs a command and returns exit status information (as a 16 bit value: the low 7 bits are the signal the process died from, if any, and the high 8 bits are the actual exit value). Backticks (``) run a command and return what it sent to STDOUT. my $exit_status = system("mail-users"); my $output_string = `ls`; What's wrong with using backticks in a void context? Strictly speaking, nothing. Stylistically speaking, it's not a good way to write maintainable code. Perl has several operators for running external commands. Backticks are one; they collect the output from the command for use in your program. The "system" function is another; it doesn't do this. Writing backticks in your program sends a clear message to the readers of your code that you wanted to collect the output of the command. Why send a clear message that isn't true? Consider this line: `cat /etc/termcap`; You forgot to check $? to see whether the program even ran correctly. Even if you wrote print `cat /etc/termcap`; this code could and probably should be written as system("cat /etc/termcap") == 0 or die "cat program failed!"; which will echo the cat command's output as it is generated, instead of waiting until the program has completed to print it out. It also checks the return value. "system" also provides direct control over whether shell wildcard processing may take place, whereas backticks do not. How can I call backticks without shell processing? This is a bit tricky. You can't simply write the command like this: @ok = `grep @opts '$search_string' @filenames`; As of Perl 5.8.0, you can use open() with multiple arguments. Just like the list forms of system() and exec(), no shell escapes happen. open( GREP, "-|", 'grep', @opts, $search_string, @filenames ); chomp(@ok = <GREP>); close GREP; You can also: my @ok = (); if (open(GREP, "-|")) { while (<GREP>) { chomp; push(@ok, $_); } close GREP; } else { exec 'grep', @opts, $search_string, @filenames; } Just as with system(), no shell escapes happen when you exec() a list. Further examples of this can be found in "Safe Pipe Opens" in perlipc. Note that if you're using Windows, no solution to this vexing issue is even possible. Even though Perl emulates fork(), you'll still be stuck, because Windows does not have an argc/argv-style API. Why can't my script read from STDIN after I gave it EOF (^D on Unix, ^Z on MS-DOS)? This happens only if your perl is compiled to use stdio instead of perlio, which is the default. Some (maybe all?) stdios set error and eof flags that you may need to clear. The POSIX module defines clearerr() that you can use. That is the technically correct way to do it. Here are some less reliable workarounds: 1 Try keeping around the seekpointer and go there, like this: my $where = tell($log_fh); seek($log_fh, $where, 0); 2 If that doesn't work, try seeking to a different part of the file and then back. 3 If that doesn't work, try seeking to a different part of the file, reading something, and then seeking back. 4 If that doesn't work, give up on your stdio package and use sysread. How can I write expect in Perl? Once upon a time, there was a library called chat2.pl (part of the standard perl distribution), which never really got finished. If you find it somewhere, *don't use it*. These days, your best bet is to look at the Expect module available from CPAN, which also requires two other modules from CPAN, IO::Pty and IO::Stty. I {changed directory, modified my environment} in a perl script. How come the change disappeared when I exited the script? How do I get my changes to be visible? Unix In the strictest sense, it can't be done--the script executes as a different process from the shell it was started from. Changes to a process are not reflected in its parent--only in any children created after the change. There is shell magic that may allow you to fake it by eval()ing the script's output in your shell; check out the comp.unix.questions FAQ for details. How do I close a process's filehandle without waiting for it to complete? Assuming your system supports such things, just send an appropriate signal to the process (see "kill" in perlfunc). It's common to first send a TERM signal, wait a little bit, and then send a KILL signal to finish it off. How do I set CPU limits? (contributed by Xho) Use the BSD::Resource module from CPAN. As an example: use BSD::Resource; setrlimit(RLIMIT_CPU,10,20) or die $!; This sets the soft and hard limits to 10 and 20 seconds, respectively. After 10 seconds of time spent running on the CPU (not "wall" time), the process will be sent a signal (XCPU on some systems) which, if not trapped, will cause the process to terminate. If that signal is trapped, then after 10 more seconds (20 seconds in total) the process will be killed with a non-trappable signal. See the BSD::Resource and your systems documentation for the gory details. How do I make a system() exit on control-C? You can't. You need to imitate the system() call (see perlipc for sample code) and then have a signal handler for the INT signal that passes the signal on to the subprocess. Or you can check for it: $rc = system($cmd); if ($rc & 127) { die "signal death" } How do I open a file without blocking? If you're lucky enough to be using a system that supports non-blocking reads (most Unixish systems do), you need only to use the "O_NDELAY" or "O_NONBLOCK" flag from the "Fcntl" module in conjunction with sysopen(): use Fcntl; sysopen(my $fh, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT, 0644) or die "can't open /foo/somefile: $!": What is socket.ph and where do I get it? It's a Perl 4 style file defining values for system networking constants. Sometimes it is built using h2ph when Perl is installed, but other times it is not. Modern programs should use "use Socket;" instead.
Generated by phpman v4.12.14 · Markdown · JSON Author: Che Dong Under GNU General Public License
2026-11-01 23:52 @216.73.217.84
CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)