=head1 NAME
-perlfaq1 - General Questions About Perl ($Revision: 1.19 $, $Date: 2005/12/31 00:54:37 $)
+perlfaq1 - General Questions About Perl ($Revision: 3606 $)
=head1 DESCRIPTION
(contributed by brian d foy)
-There is often a matter of opinion and taste, and there isn't any
-one answer that fits anyone. In general, you want to use either
-the current stable release, or the stable release immediately prior
-to that one. Currently, those are perl5.8.x and perl5.6.x, respectively.
+There is often a matter of opinion and taste, and there isn't any one
+answer that fits anyone. In general, you want to use either the current
+stable release, or the stable release immediately prior to that one.
+Currently, those are perl5.8.x and perl5.6.x, respectively.
-Beyond that, you have to consider several things and decide which
-is best for you.
+Beyond that, you have to consider several things and decide which is best
+for you.
=over 4
=item *
-If things aren't broken, upgrading perl may break
-them (or at least issue new warnings).
+If things aren't broken, upgrading perl may break them (or at least issue
+new warnings).
=item *
=item *
-The Perl community is geared toward supporting the most
-recent releases, so you'll have an easier time finding help for
-those.
+The Perl community is geared toward supporting the most recent releases,
+so you'll have an easier time finding help for those.
=item *
-Versions prior to perl5.004 had serious security problems with
-buffer overflows, and in some cases have CERT advisories (for
-instance, http://www.cert.org/advisories/CA-1997-17.html ).
+Versions prior to perl5.004 had serious security problems with buffer
+overflows, and in some cases have CERT advisories (for instance,
+http://www.cert.org/advisories/CA-1997-17.html ).
=item *
-The latest versions are probably the least deployed and
-widely tested, so you may want to wait a few months after their
-release and see what problems others have if you are risk averse.
+The latest versions are probably the least deployed and widely tested, so
+you may want to wait a few months after their release and see what
+problems others have if you are risk averse.
=item *
-The immediate, previous releases (i.e. perl5.6.x ) are usually
-maintained for a while, although not at the same level as the
-current releases.
+The immediate, previous releases (i.e. perl5.6.x ) are usually maintained
+for a while, although not at the same level as the current releases.
=item *
-No one is actively supporting perl4.x. Five years ago it was
-a dead camel carcass (according to this document). Now it's barely
-a skeleton as its whitewashed bones have fractured or eroded.
+No one is actively supporting perl4.x. Five years ago it was a dead
+camel carcass (according to this document). Now it's barely a skeleton
+as its whitewashed bones have fractured or eroded.
=item *
-There is no perl6.x for the next couple of years. Stay tuned,
-but don't worry that you'll have to change major versions of Perl
-soon (i.e. before 2006).
+There is no perl6.x for the next couple of years. Stay tuned, but don't
+worry that you'll have to change major versions of Perl soon (i.e. before
+2008).
=item *
-There are really two tracks of perl development: a
-maintenance version and an experimental version. The
-maintenance versions are stable, and have an even number
-as the minor release (i.e. perl5.8.x, where 8 is the minor
-release). The experimental versions may include features that
-don't make it into the stable versions, and have an odd number
-as the minor release (i.e. perl5.9.x, where 9 is the minor release).
+There are really two tracks of perl development: a maintenance version
+and an experimental version. The maintenance versions are stable, and
+have an even number as the minor release (i.e. perl5.8.x, where 8 is the
+minor release). The experimental versions may include features that
+don't make it into the stable versions, and have an odd number as the
+minor release (i.e. perl5.9.x, where 9 is the minor release).
=back
=head2 What is Ponie?
-At The O'Reilly Open Source Software Convention in 2003, Artur
-Bergman, Fotango, and The Perl Foundation announced a project to
-run perl5 on the Parrot virtual machine named Ponie. Ponie stands for
-Perl On New Internal Engine. The Perl 5.10 language implementation
-will be used for Ponie, and there will be no language level
-differences between perl5 and ponie. Ponie is not a complete rewrite
-of perl5.
+(contributed by brian d foy)
+
+Ponie stands for "Perl On the New Internal Engine", started by Arthur
+Bergman from Fotango in 2003, and subsequently run as a project of The
+Perl Foundation. Instead of using the current Perl internals, Ponie
+creates a new one that provides a translation path from Perl 5 to Perl 6
+(or anything else that targets Parrot, actually). You can also just keep
+using Perl 5 with Parrot, the virtual machine which will compile and run
+Perl 6 bytecode.
-For more details, see http://www.poniecode.org/
+You can get more information at http://www.poniecode.org/ and
+http://www.parrotcode.org .
=head2 What is perl6?
=head2 What is a JAPH?
-These are the "just another perl hacker" signatures that some people
-sign their postings with. Randal Schwartz made these famous. About
-100 of the earlier ones are available from
-http://www.cpan.org/misc/japh .
+(contributed by brian d foy)
+
+JAPH stands for "Just another Perl hacker,", which Randal Schwartz used
+to sign email and usenet messages starting in the late 1980s. He
+previously used the phrase with many subjects ("Just another x hacker,"),
+so to distinguish his JAPH, he started to write them as Perl programs:
+
+ print "Just another Perl hacker,";
+
+Note the trailing comma and space, which allows the addition of other
+JAxH clauses for his many other interests.
+
+Other people picked up on this and started to write clever or obfuscated
+programs to produce the same output, spinning things quickly out of
+control while still providing hours of amusement for their creators and
+readers.
+
+CPAN has several JAPH programs at http://www.cpan.org/misc/japh .
=head2 Where can I get a list of Larry Wall witticisms?
-Over a hundred quips by Larry, from postings of his or source code,
-can be found at http://www.cpan.org/misc/lwall-quotes.txt.gz .
-
-=head2 How can I convince my sysadmin/supervisor/employees to use version 5/5.6.1/Perl instead of some other language?
-
-If your manager or employees are wary of unsupported software, or
-software which doesn't officially ship with your operating system, you
-might try to appeal to their self-interest. If programmers can be
-more productive using and utilizing Perl constructs, functionality,
-simplicity, and power, then the typical manager/supervisor/employee
-may be persuaded. Regarding using Perl in general, it's also
-sometimes helpful to point out that delivery times may be reduced
-using Perl compared to other languages.
-
-If you have a project which has a bottleneck, especially in terms of
-translation or testing, Perl almost certainly will provide a viable,
-quick solution. In conjunction with any persuasion effort, you
-should not fail to point out that Perl is used, quite extensively, and
-with extremely reliable and valuable results, at many large computer
-software and hardware companies throughout the world. In fact,
-many Unix vendors now ship Perl by default. Support is usually
-just a news-posting away, if you can't find the answer in the
-I<comprehensive> documentation, including this FAQ.
-
-See http://www.perl.org/advocacy/ for more information.
-
-If you face reluctance to upgrading from an older version of perl,
-then point out that version 4 is utterly unmaintained and unsupported
-by the Perl Development Team. Another big sell for Perl5 is the large
-number of modules and extensions which greatly reduce development time
-for any given task. Also mention that the difference between version
-4 and version 5 of Perl is like the difference between awk and C++.
-(Well, OK, maybe it's not quite that distinct, but you get the idea.)
-If you want support and a reasonable guarantee that what you're
-developing will continue to work in the future, then you have to run
-the supported version. As of December 2003 that means running either
-5.8.2 (released in November 2003), or one of the older releases like
-5.6.2 (also released in November 2003; a maintenance release to let perl
-5.6 compile on newer systems as 5.6.1 was released in April 2001) or
-5.005_03 (released in March 1999),
-although 5.004_05 isn't that bad if you B<absolutely> need such an old
-version (released in April 1999) for stability reasons.
-Anything older than 5.004_05 shouldn't be used.
-
-Of particular note is the massive bug hunt for buffer overflow
-problems that went into the 5.004 release. All releases prior to
-that, including perl4, are considered insecure and should be upgraded
-as soon as possible.
-
-In August 2000 in all Linux distributions a new security problem was
-found in the optional 'suidperl' (not built or installed by default)
-in all the Perl branches 5.6, 5.005, and 5.004, see
-http://www.cpan.org/src/5.0/sperl-2000-08-05/
-Perl maintenance releases 5.6.1 and 5.8.0 have this security hole closed.
-Most, if not all, Linux distribution have patches for this
-vulnerability available, see http://www.linuxsecurity.com/advisories/ ,
-but the most recommendable way is to upgrade to at least Perl 5.6.1.
+(contributed by brian d foy)
+
+Google "larry wall quotes"! You might even try the "I feel lucky" button.
+:)
+
+Wikiquote has the witticisms from Larry along with their source,
+including his usenet postings and source code comments.
+
+If you want a plain text file, try
+http://www.cpan.org/misc/lwall-quotes.txt.gz .
+
+=head2 How can I convince others to use Perl?
+
+(contributed by brian d foy)
+
+Appeal to their self interest! If Perl is new (and thus scary) to them,
+find something that Perl can do to solve one of their problems. That
+might mean that Perl either saves them something (time, headaches, money)
+or gives them something (flexibility, power, testability).
+
+In general, the benefit of a language is closely related to the skill of
+the people using that language. If you or your team can be more faster,
+better, and stronger through Perl, you'll deliver more value. Remember,
+people often respond better to what they get out of it. If you run
+into resistance, figure out what those people get out of the other
+choice and how Perl might satisfy that requirement.
+
+You don't have to worry about finding or paying for Perl; it's freely
+available and several popular operating systems come with Perl. Community
+support in places such as Perlmonks ( http://www.perlmonks.com )
+and the various Perl mailing lists ( http://lists.perl.org ) means that
+you can usually get quick answers to your problems.
+
+Finally, keep in mind that Perl might not be the right tool for every
+job. You're a much better advocate if your claims are reasonable and
+grounded in reality. Dogmatically advocating anything tends to make
+people discount your message. Be honest about possible disadvantages
+to your choice of Perl since any choice has trade-offs.
+
+You might find these links useful:
+
+=over 4
+
+=item * http://perltraining.com.au/whyperl.html
+
+=item * http://www.perl.org/advocacy/whyperl.html
+
+=back
+
+=head1 REVISION
+
+Revision: $Revision: 3606 $
+
+Date: $Date: 2006-03-06 12:05:47 +0100 (lun, 06 mar 2006) $
+
+See L<perlfaq> for source control details and availability.
=head1 AUTHOR AND COPYRIGHT
=head1 NAME
-perlfaq5 - Files and Formats ($Revision: 1.42 $, $Date: 2005/12/31 00:54:37 $)
+perlfaq5 - Files and Formats ($Revision: 3606 $)
=head1 DESCRIPTION
Use select() to choose the desired handle, then set its
per-filehandle variables.
- $old_fh = select(OUTPUT_HANDLE);
- $| = 1;
- select($old_fh);
+ $old_fh = select(OUTPUT_HANDLE);
+ $| = 1;
+ select($old_fh);
Some idioms can handle this in a single statement:
- select((select(OUTPUT_HANDLE), $| = 1)[0]);
+ select((select(OUTPUT_HANDLE), $| = 1)[0]);
- $| = 1, select $_ for select OUTPUT_HANDLE;
+ $| = 1, select $_ for select OUTPUT_HANDLE;
Some modules offer object-oriented access to handles and their
variables, although they may be overkill if this is the only
thing you do with them. You can use IO::Handle:
- use IO::Handle;
- open(DEV, ">/dev/printer"); # but is this?
- DEV->autoflush(1);
+ use IO::Handle;
+ open(DEV, ">/dev/printer"); # but is this?
+ DEV->autoflush(1);
or IO::Socket:
- use IO::Socket; # this one is kinda a pipe?
+ use IO::Socket; # this one is kinda a pipe?
my $sock = IO::Socket::INET->new( 'www.example.com:80' );
- $sock->autoflush();
+ $sock->autoflush();
=head2 How do I change one line in a file/delete a line in a file/insert a line in the middle of a file/append to the beginning of a file?
X<file, editing>
If your text file doesn't end with a newline, then it's not really a
proper text file, so this may report one fewer line than you expect.
- $lines = 0;
- open(FILE, $filename) or die "Can't open `$filename': $!";
- while (sysread FILE, $buffer, 4096) {
- $lines += ($buffer =~ tr/\n//);
- }
- close FILE;
+ $lines = 0;
+ open(FILE, $filename) or die "Can't open `$filename': $!";
+ while (sysread FILE, $buffer, 4096) {
+ $lines += ($buffer =~ tr/\n//);
+ }
+ close FILE;
This assumes no funny games with newline translations.
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
+ # ...
+ {
+ 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<.c> files in the current directory,
leaving a backup of the original data from each file in a new
Otherwise, you can use the File::Temp module.
- use File::Temp qw/ tempfile tempdir /;
+ use File::Temp qw/ tempfile tempdir /;
- $dir = tempdir( CLEANUP => 1 );
- ($fh, $filename) = tempfile( DIR => $dir );
+ $dir = tempdir( CLEANUP => 1 );
+ ($fh, $filename) = tempfile( DIR => $dir );
- # or if you don't need to know the filename
+ # or if you don't need to know the filename
- $fh = tempfile( DIR => $dir );
+ $fh = tempfile( DIR => $dir );
The File::Temp has been a standard module since Perl 5.6.1. If you
don't have a modern enough Perl installed, use the C<new_tmpfile>
class method from the IO::File module to get a filehandle opened for
reading and writing. Use it if you don't need to know the file's name:
- use IO::File;
- $fh = IO::File->new_tmpfile()
+ use IO::File;
+ $fh = IO::File->new_tmpfile()
or die "Unable to make new temporary file: $!";
If you're committed to creating a temporary file by hand, use the
process ID and/or the current time-value. If you need to have many
temporary files in one process, use a counter:
- BEGIN {
+ BEGIN {
use Fcntl;
my $temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMPDIR} || $ENV{TEMP};
my $base_name = sprintf("%s/%d-%d-0000", $temp_dir, $$, time());
+
sub temp_file {
- local *FH;
- my $count = 0;
- until (defined(fileno(FH)) || $count++ > 100) {
+ local *FH;
+ my $count = 0;
+ until (defined(fileno(FH)) || $count++ > 100) {
$base_name =~ s/-(\d+)$/"-" . (1 + $1)/e;
# O_EXCL is required for security reasons.
sysopen(FH, $base_name, O_WRONLY|O_EXCL|O_CREAT);
- }
- if (defined(fileno(FH))
+ }
+
+ if (defined(fileno(FH))
return (*FH, $base_name);
- } else {
+ }
+ else {
return ();
}
}
- }
+ }
=head2 How can I manipulate fixed-record-length files?
X<fixed-length> X<file, fixed-length records>
some fixed-format input lines, in this case from the output of a normal,
Berkeley-style ps:
- # sample input line:
- # 15158 p5 T 0:00 perl /home/tchrist/scripts/now-what
- my $PS_T = 'A6 A4 A7 A5 A*';
- open my $ps, '-|', 'ps';
- print scalar <$ps>;
- my @fields = qw( pid tt stat time command );
- while (<$ps>) {
- my %process;
- @process{@fields} = unpack($PS_T, $_);
+ # sample input line:
+ # 15158 p5 T 0:00 perl /home/tchrist/scripts/now-what
+ my $PS_T = 'A6 A4 A7 A5 A*';
+ open my $ps, '-|', 'ps';
+ print scalar <$ps>;
+ my @fields = qw( pid tt stat time command );
+ while (<$ps>) {
+ my %process;
+ @process{@fields} = unpack($PS_T, $_);
for my $field ( @fields ) {
- print "$field: <$process{$field}>\n";
+ print "$field: <$process{$field}>\n";
}
print 'line=', pack($PS_T, @process{@fields} ), "\n";
- }
+ }
We've used a hash slice in order to easily handle the fields of each row.
Storing the keys in an array means it's easy to operate on them as a
group or loop over them with for. It also avoids polluting the program
with global variables and using symbolic references.
-=head2 How can I make a filehandle local to a subroutine? How do I pass filehandles between subroutines? How do I make an array of filehandles?
+=head2 How can I make a filehandle local to a subroutine? How do I pass filehandles between subroutines? How do I make an array of filehandles?
X<filehandle, local> X<filehandle, passing> X<filehandle, reference>
As of perl5.6, open() autovivifies file and directory handles
process_file( $fh );
+If you like, you can store these filehandles in an array or a hash.
+If you access them directly, they aren't simple scalars and you
+need to give C<print> a little help by placing the filehandle
+reference in braces. Perl can only figure it out on its own when
+the filehandle reference is a simple scalar.
+
+ my @fhs = ( $fh1, $fh2, $fh3 );
+
+ for( $i = 0; $i <= $#fhs; $i++ ) {
+ print {$fhs[$i]} "just another Perl answer, \n";
+ }
+
+
Before perl5.6, you had to deal with various typeglob idioms
which you may see in older code.
in a place that a filehandle is expected. Here are ways
to get indirect filehandles:
- $fh = SOME_FH; # bareword is strict-subs hostile
- $fh = "SOME_FH"; # strict-refs hostile; same package only
- $fh = *SOME_FH; # typeglob
- $fh = \*SOME_FH; # ref to typeglob (bless-able)
- $fh = *SOME_FH{IO}; # blessed IO::Handle from *SOME_FH typeglob
+ $fh = SOME_FH; # bareword is strict-subs hostile
+ $fh = "SOME_FH"; # strict-refs hostile; same package only
+ $fh = *SOME_FH; # typeglob
+ $fh = \*SOME_FH; # ref to typeglob (bless-able)
+ $fh = *SOME_FH{IO}; # blessed IO::Handle from *SOME_FH typeglob
Or, you can use the C<new> method from one of the IO::* modules to
create an anonymous filehandle, store that in a scalar variable,
and use it as though it were a normal filehandle.
- use IO::Handle; # 5.004 or higher
- $fh = IO::Handle->new();
+ use IO::Handle; # 5.004 or higher
+ $fh = IO::Handle->new();
Then use any of those as you would a normal filehandle. Anywhere that
Perl is expecting a filehandle, an indirect filehandle may be used
the C<< <FH> >> diamond operator will accept either a named filehandle
or a scalar variable containing one:
- ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR);
- print $ofh "Type it: ";
- $got = <$ifh>
- print $efh "What was that: $got";
+ ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR);
+ print $ofh "Type it: ";
+ $got = <$ifh>
+ print $efh "What was that: $got";
If you're passing a filehandle to a function, you can write
the function in two ways:
- sub accept_fh {
- my $fh = shift;
- print $fh "Sending to indirect filehandle\n";
- }
+ sub accept_fh {
+ my $fh = shift;
+ print $fh "Sending to indirect filehandle\n";
+ }
Or it can localize a typeglob and use the filehandle directly:
- sub accept_fh {
- local *FH = shift;
- print FH "Sending to localized filehandle\n";
- }
+ sub accept_fh {
+ local *FH = shift;
+ print FH "Sending to localized filehandle\n";
+ }
Both styles work with either objects or typeglobs of real filehandles.
(They might also work with strings under some circumstances, but this
is risky.)
- accept_fh(*STDOUT);
- accept_fh($handle);
+ accept_fh(*STDOUT);
+ accept_fh($handle);
In the examples above, we assigned the filehandle to a scalar variable
before using it. That is because only simple scalar variables, not
something other than a simple scalar variable as a filehandle is
illegal and won't even compile:
- @fd = (*STDIN, *STDOUT, *STDERR);
- print $fd[1] "Type it: "; # WRONG
- $got = <$fd[0]> # WRONG
- print $fd[2] "What was that: $got"; # WRONG
+ @fd = (*STDIN, *STDOUT, *STDERR);
+ print $fd[1] "Type it: "; # WRONG
+ $got = <$fd[0]> # WRONG
+ print $fd[2] "What was that: $got"; # WRONG
With C<print> and C<printf>, you get around this by using a block and
an expression where you would place the filehandle:
- print { $fd[1] } "funny stuff\n";
- printf { $fd[1] } "Pity the poor %x.\n", 3_735_928_559;
- # Pity the poor deadbeef.
+ print { $fd[1] } "funny stuff\n";
+ printf { $fd[1] } "Pity the poor %x.\n", 3_735_928_559;
+ # Pity the poor deadbeef.
That block is a proper block like any other, so you can put more
complicated code there. This sends the message out to one of two places:
- $ok = -x "/bin/cat";
- print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n";
- print { $fd[ 1+ ($ok || 0) ] } "cat stat $ok\n";
+ $ok = -x "/bin/cat";
+ print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n";
+ print { $fd[ 1+ ($ok || 0) ] } "cat stat $ok\n";
This approach of treating C<print> and C<printf> like object methods
calls doesn't work for the diamond operator. That's because it's a
would work, but only because readline() requires a typeglob. It doesn't
work with objects or strings, which might be a bug we haven't fixed yet.
- $got = readline($fd[0]);
+ $got = readline($fd[0]);
Let it be noted that the flakiness of indirect filehandles is not
related to whether they're strings, typeglobs, objects, or anything else.
This subroutine will add commas to your number:
sub commify {
- local $_ = shift;
- 1 while s/^([-+]?\d+)(\d{3})/$1,$2/;
- return $_;
- }
+ 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;
+ 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;
+ 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;
=head2 How can I translate tildes (~) in a filename?
X<tilde> X<tilde expansion>
Because you're using something like this, which truncates the file and
I<then> gives you read-write access:
- open(FH, "+> /path/name"); # WRONG (almost always)
+ open(FH, "+> /path/name"); # WRONG (almost always)
Whoops. You should instead use this, which will fail if the file
doesn't exist.
- open(FH, "+< /path/name"); # open for update
+ open(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
- use Fcntl;
+ use Fcntl;
To open file for reading:
- open(FH, "< $path") || die $!;
- sysopen(FH, $path, O_RDONLY) || die $!;
+ open(FH, "< $path") || die $!;
+ sysopen(FH, $path, O_RDONLY) || die $!;
To open file for writing, create new file if needed or else truncate old file:
- open(FH, "> $path") || die $!;
- sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT) || die $!;
- sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666) || die $!;
+ open(FH, "> $path") || die $!;
+ sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT) || die $!;
+ sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666) || die $!;
To open file for writing, create new file, file must not exist:
- sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT) || die $!;
- sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT, 0666) || die $!;
+ sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT) || die $!;
+ sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT, 0666) || die $!;
To open file for appending, create if necessary:
- open(FH, ">> $path") || die $!;
- sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT) || die $!;
- sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT, 0666) || die $!;
+ open(FH, ">> $path") || die $!;
+ sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT) || die $!;
+ sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT, 0666) || die $!;
To open file for appending, file must exist:
- sysopen(FH, $path, O_WRONLY|O_APPEND) || die $!;
+ sysopen(FH, $path, O_WRONLY|O_APPEND) || die $!;
To open file for update, file must exist:
- open(FH, "+< $path") || die $!;
- sysopen(FH, $path, O_RDWR) || die $!;
+ open(FH, "+< $path") || die $!;
+ sysopen(FH, $path, O_RDWR) || die $!;
To open file for update, create file if necessary:
- sysopen(FH, $path, O_RDWR|O_CREAT) || die $!;
- sysopen(FH, $path, O_RDWR|O_CREAT, 0666) || die $!;
+ sysopen(FH, $path, O_RDWR|O_CREAT) || die $!;
+ sysopen(FH, $path, O_RDWR|O_CREAT, 0666) || die $!;
To open file for update, file must not exist:
- sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT) || die $!;
- sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT, 0666) || die $!;
+ sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT) || die $!;
+ sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT, 0666) || die $!;
To open a file without blocking, creating if necessary:
- sysopen(FH, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT)
+ sysopen(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
If your operating system supports a proper mv(1) utility or its
functional equivalent, this works:
- rename($old, $new) or system("mv", $old, $new);
+ rename($old, $new) or system("mv", $old, $new);
It may be more portable to use the File::Copy module instead.
You just copy to the new file to the new name (checking return
A common bit of code B<NOT TO USE> is this:
- sleep(3) while -e "file.lock"; # PLEASE DO NOT USE
- open(LCK, "> file.lock"); # THIS BROKEN CODE
+ sleep(3) while -e "file.lock"; # PLEASE DO NOT USE
+ open(LCK, "> file.lock"); # THIS BROKEN CODE
This is a classic race condition: you take two steps to do something
which must be done in one. That's why computer hardware provides an
atomic test-and-set instruction. In theory, this "ought" to work:
- sysopen(FH, "file.lock", O_WRONLY|O_EXCL|O_CREAT)
+ sysopen(FH, "file.lock", O_WRONLY|O_EXCL|O_CREAT)
or die "can't open file.lock: $!";
except that lamentably, file creation (and deletion) is not atomic
Anyway, this is what you can do if you can't help yourself.
- use Fcntl qw(:DEFAULT :flock);
- sysopen(FH, "numfile", O_RDWR|O_CREAT) or die "can't open numfile: $!";
- flock(FH, LOCK_EX) or die "can't flock numfile: $!";
- $num = <FH> || 0;
- seek(FH, 0, 0) or die "can't rewind numfile: $!";
- truncate(FH, 0) or die "can't truncate numfile: $!";
- (print FH $num+1, "\n") or die "can't write numfile: $!";
- close FH or die "can't close numfile: $!";
+ use Fcntl qw(:DEFAULT :flock);
+ sysopen(FH, "numfile", O_RDWR|O_CREAT) or die "can't open numfile: $!";
+ flock(FH, LOCK_EX) or die "can't flock numfile: $!";
+ $num = <FH> || 0;
+ seek(FH, 0, 0) or die "can't rewind numfile: $!";
+ truncate(FH, 0) or die "can't truncate numfile: $!";
+ (print FH $num+1, "\n") or die "can't write numfile: $!";
+ close FH or die "can't close numfile: $!";
Here's a much better web-page hit counter:
- $hits = int( (time() - 850_000_000) / rand(1_000) );
+ $hits = int( (time() - 850_000_000) / rand(1_000) );
If the count doesn't impress your friends, then the code might. :-)
If you're just trying to patch a binary, in many cases something as
simple as this works:
- perl -i -pe 's{window manager}{window mangler}g' /usr/bin/emacs
+ perl -i -pe 's{window manager}{window mangler}g' /usr/bin/emacs
However, if you have fixed sized records, then you might do something more
like this:
- $RECSIZE = 220; # size of record, in bytes
- $recno = 37; # which record to update
- open(FH, "+<somewhere") || die "can't update somewhere: $!";
- seek(FH, $recno * $RECSIZE, 0);
- read(FH, $record, $RECSIZE) == $RECSIZE || die "can't read record $recno: $!";
- # munge the record
- seek(FH, -$RECSIZE, 1);
- print FH $record;
- close FH;
+ $RECSIZE = 220; # size of record, in bytes
+ $recno = 37; # which record to update
+ open(FH, "+<somewhere") || die "can't update somewhere: $!";
+ seek(FH, $recno * $RECSIZE, 0);
+ read(FH, $record, $RECSIZE) == $RECSIZE || die "can't read record $recno: $!";
+ # munge the record
+ seek(FH, -$RECSIZE, 1);
+ print FH $record;
+ close FH;
Locking and error checking are left as an exercise for the reader.
Don't forget them or you'll be quite sorry.
Here's an example:
- $write_secs = (stat($file))[9];
- printf "file %s updated at %s\n", $file,
+ $write_secs = (stat($file))[9];
+ printf "file %s updated at %s\n", $file,
scalar localtime($write_secs);
If you prefer something more legible, use the File::stat module
(part of the standard distribution in version 5.004 and later):
- # error checking left as an exercise for reader.
- use File::stat;
- use Time::localtime;
- $date_string = ctime(stat($file)->mtime);
- print "file $file updated at $date_string\n";
+ # error checking left as an exercise for reader.
+ use File::stat;
+ use Time::localtime;
+ $date_string = ctime(stat($file)->mtime);
+ print "file $file updated at $date_string\n";
The POSIX::strftime() approach has the benefit of being,
in theory, independent of the current locale. See L<perllocale>
read and write times from its first argument to all the rest
of them.
- if (@ARGV < 2) {
- die "usage: cptimes timestamp_file other_files ...\n";
- }
- $timestamp = shift;
- ($atime, $mtime) = (stat($timestamp))[8,9];
- utime $atime, $mtime, @ARGV;
+ if (@ARGV < 2) {
+ die "usage: cptimes timestamp_file other_files ...\n";
+ }
+ $timestamp = shift;
+ ($atime, $mtime) = (stat($timestamp))[8,9];
+ utime $atime, $mtime, @ARGV;
Error checking is, as usual, left as an exercise for the reader.
If you only have to do this once, you can print individually
to each filehandle.
- for $fh (FH1, FH2, FH3) { print $fh "whatever\n" }
+ for $fh (FH1, FH2, FH3) { print $fh "whatever\n" }
=head2 How can I read in an entire file all at once?
X<slurp> X<file, slurping>
use File::Slurp;
$all_of_it = read_file($filename); # entire file in scalar
- @all_lines = read_file($filename); # one line perl element
+ @all_lines = read_file($filename); # one line perl element
The customary Perl approach for processing all the lines in a file is to
do so one line at a time:
- open (INPUT, $file) || die "can't open $file: $!";
- while (<INPUT>) {
- chomp;
- # do something with $_
- }
- close(INPUT) || die "can't close $file: $!";
+ open (INPUT, $file) || die "can't open $file: $!";
+ while (<INPUT>) {
+ chomp;
+ # do something with $_
+ }
+ close(INPUT) || die "can't close $file: $!";
This is tremendously more efficient than reading the entire file into
memory as an array of lines and then processing it one element at a time,
which is often--if not almost always--the wrong approach. Whenever
you see someone do this:
- @lines = <INPUT>;
+ @lines = <INPUT>;
you should think long and hard about why you need everything loaded at
once. It's just not a scalable solution. You might also find it more
You can read the entire filehandle contents into a scalar.
- {
+ {
local(*INPUT, $/);
open (INPUT, $file) || die "can't open $file: $!";
$var = <INPUT>;
- }
+ }
That temporarily undefs your record separator, and will automatically
close the file at block exit. If the file is already open, just use this:
- $var = do { local $/; <INPUT> };
+ $var = do { local $/; <INPUT> };
For ordinary files you can also use the read function.
interface (POSIX), you can use the following code, which you'll note
turns off echo processing as well.
- #!/usr/bin/perl -w
- use strict;
- $| = 1;
- for (1..4) {
- my $got;
- print "gimme: ";
- $got = getone();
- print "--> $got\n";
- }
+ #!/usr/bin/perl -w
+ use strict;
+ $| = 1;
+ for (1..4) {
+ my $got;
+ print "gimme: ";
+ $got = getone();
+ print "--> $got\n";
+ }
exit;
- BEGIN {
+ BEGIN {
use POSIX qw(:termios_h);
my ($term, $oterm, $echo, $noecho, $fd_stdin);
$noecho = $oterm & ~$echo;
sub cbreak {
- $term->setlflag($noecho);
- $term->setcc(VTIME, 1);
- $term->setattr($fd_stdin, TCSANOW);
- }
-
+ $term->setlflag($noecho);
+ $term->setcc(VTIME, 1);
+ $term->setattr($fd_stdin, TCSANOW);
+ }
+
sub cooked {
- $term->setlflag($oterm);
- $term->setcc(VTIME, 0);
- $term->setattr($fd_stdin, TCSANOW);
- }
+ $term->setlflag($oterm);
+ $term->setcc(VTIME, 0);
+ $term->setattr($fd_stdin, TCSANOW);
+ }
sub getone {
- my $key = '';
- cbreak();
- sysread(STDIN, $key, 1);
- cooked();
- return $key;
- }
+ my $key = '';
+ cbreak();
+ sysread(STDIN, $key, 1);
+ cooked();
+ return $key;
+ }
- }
+ }
- END { cooked() }
+ END { cooked() }
The Term::ReadKey module from CPAN may be easier to use. Recent versions
include also support for non-portable systems as well.
- use Term::ReadKey;
- open(TTY, "</dev/tty");
- print "Gimme a char: ";
- ReadMode "raw";
- $key = ReadKey 0, *TTY;
- ReadMode "normal";
- printf "\nYou said %s, char number %03d\n",
- $key, ord $key;
+ use Term::ReadKey;
+ open(TTY, "</dev/tty");
+ print "Gimme a char: ";
+ ReadMode "raw";
+ $key = ReadKey 0, *TTY;
+ ReadMode "normal";
+ printf "\nYou said %s, char number %03d\n",
+ $key, ord $key;
=head2 How can I tell whether there's a character waiting on a filehandle?
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);
- }
+ 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 I<h2ph> tool that
can be C<require>d. FIONREAD ends up defined as a function in the
I<sys/ioctl.ph> file:
- require 'sys/ioctl.ph';
+ require 'sys/ioctl.ph';
- $size = pack("L", 0);
- ioctl(FH, FIONREAD(), $size) or die "Couldn't call ioctl: $!\n";
- $size = unpack("L", $size);
+ $size = pack("L", 0);
+ ioctl(FH, FIONREAD(), $size) or die "Couldn't call ioctl: $!\n";
+ $size = unpack("L", $size);
If I<h2ph> wasn't installed or doesn't work for you, you can
I<grep> the include files by hand:
- % grep FIONREAD /usr/include/*/*
- /usr/include/asm/ioctls.h:#define FIONREAD 0x541B
+ % 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
+ % 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
+ $FIONREAD = 0x4004667f; # XXX: opsys dependent
- $size = pack("L", 0);
- ioctl(FH, $FIONREAD, $size) or die "Couldn't call ioctl: $!\n";
- $size = unpack("L", $size);
+ $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 I<not> files.
First try
- seek(GWFILE, 0, 1);
+ seek(GWFILE, 0, 1);
The statement C<seek(GWFILE, 0, 1)> doesn't change the current position,
but it does clear the end-of-file condition on the handle, so that the
If you check L<perlfunc/open>, you'll see that several of the ways
to call open() should do the trick. For example:
- open(LOG, ">>/foo/logfile");
- open(STDERR, ">&LOG");
+ open(LOG, ">>/foo/logfile");
+ open(STDERR, ">&LOG");
Or even with a literal numeric descriptor:
numeric descriptor as with MHCONTEXT above. But if you really have
to, you may be able to do this:
- require 'sys/syscall.ph';
- $rc = syscall(&SYS_close, $fd + 0); # must force numeric
- die "can't sysclose $fd: $!" unless $rc == -1;
+ require 'sys/syscall.ph';
+ $rc = syscall(&SYS_close, $fd + 0); # must force numeric
+ die "can't sysclose $fd: $!" unless $rc == -1;
Or, just use the fdopen(3S) feature of open():
- {
+ {
local *F;
open F, "<&=$fd" or die "Cannot reopen fd=$fd: $!";
close F;
- }
+ }
=head2 Why can't I use "C:\temp\foo" in DOS paths? Why doesn't `C:\temp\foo.exe` work?
X<filename, DOS issues>
Here's an algorithm from the Camel Book:
- srand;
- rand($.) < 1 && ($line = $_) while <>;
+ srand;
+ rand($.) < 1 && ($line = $_) while <>;
This has a significant advantage in space over reading the whole file
in. You can find a proof of this method in I<The Art of Computer
Saying
- print "@lines\n";
+ print "@lines\n";
joins together the elements of C<@lines> with a space between them.
If C<@lines> were C<("little", "fluffy", "clouds")> then the above
statement would print
- little fluffy clouds
+ little fluffy clouds
but if each element of C<@lines> was a line of text, ending a newline
character C<("little\n", "fluffy\n", "clouds\n")> then it would print:
- little
- fluffy
- clouds
+ little
+ fluffy
+ clouds
If your array contains lines, just print them:
- print @lines;
+ print @lines;
+
+=head1 REVISION
+
+Revision: $Revision: 3606 $
+
+Date: $Date: 2006-03-06 12:05:47 +0100 (lun, 06 mar 2006) $
+
+See L<perlfaq> for source control details and availability.
=head1 AUTHOR AND COPYRIGHT
projects / p5sagit/p5-mst-13.2.git / commitdiff