diff options
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlfaq5.pod')
-rw-r--r-- | Master/tlpkg/tlperl/lib/pods/perlfaq5.pod | 1574 |
1 files changed, 0 insertions, 1574 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlfaq5.pod b/Master/tlpkg/tlperl/lib/pods/perlfaq5.pod deleted file mode 100644 index 60bd08306d5..00000000000 --- a/Master/tlpkg/tlperl/lib/pods/perlfaq5.pod +++ /dev/null @@ -1,1574 +0,0 @@ -=head1 NAME - -perlfaq5 - Files and Formats - -=head1 DESCRIPTION - -This section deals with I/O and the "f" issues: filehandles, flushing, -formats, and footers. - -=head2 How do I flush/unbuffer an output filehandle? Why must I do this? -X<flush> X<buffer> X<unbuffer> X<autoflush> - -(contributed by brian d foy) - -You might like to read Mark Jason Dominus's "Suffering From Buffering" -at L<http://perl.plover.com/FAQs/Buffering.html> . - -Perl normally buffers output so it doesn't make a system call for every -bit of output. By saving up output, it makes fewer expensive system calls. -For instance, in this little bit of code, you want to print a dot to the -screen for every line you process to watch the progress of your program. -Instead of seeing a dot for every line, Perl buffers the output and you -have a long wait before you see a row of 50 dots all at once: - - # long wait, then row of dots all at once - while( <> ) { - print "."; - print "\n" unless ++$count % 50; - - #... expensive line processing operations - } - -To get around this, you have to unbuffer the output filehandle, in this -case, C<STDOUT>. You can set the special variable C<$|> to a true value -(mnemonic: making your filehandles "piping hot"): - - $|++; - - # dot shown immediately - while( <> ) { - print "."; - print "\n" unless ++$count % 50; - - #... expensive line processing operations - } - -The C<$|> is one of the per-filehandle special variables, so each -filehandle has its own copy of its value. If you want to merge -standard output and standard error for instance, you have to unbuffer -each (although STDERR might be unbuffered by default): - - { - my $previous_default = select(STDOUT); # save previous default - $|++; # autoflush STDOUT - select(STDERR); - $|++; # autoflush STDERR, to be sure - select($previous_default); # restore previous default - } - - # now should alternate . and + - while( 1 ) { - sleep 1; - print STDOUT "."; - print STDERR "+"; - print STDOUT "\n" unless ++$count % 25; - } - -Besides the C<$|> special variable, you can use C<binmode> to give -your filehandle a C<:unix> layer, which is unbuffered: - - binmode( STDOUT, ":unix" ); - - while( 1 ) { - sleep 1; - print "."; - print "\n" unless ++$count % 50; - } - -For more information on output layers, see the entries for C<binmode> -and L<open> in L<perlfunc>, and the L<PerlIO> module documentation. - -If you are using L<IO::Handle> or one of its subclasses, you can -call the C<autoflush> method to change the settings of the -filehandle: - - use IO::Handle; - open my( $io_fh ), ">", "output.txt"; - $io_fh->autoflush(1); - -The L<IO::Handle> objects also have a C<flush> method. You can flush -the buffer any time you want without auto-buffering - - $io_fh->flush; - -=head2 How do I change, delete, or insert a line in a file, or append to the beginning of a file? -X<file, editing> - -(contributed by brian d foy) - -The basic idea of inserting, changing, or deleting a line from a text -file involves reading and printing the file to the point you want to -make the change, making the change, then reading and printing the rest -of the file. Perl doesn't provide random access to lines (especially -since the record input separator, C<$/>, is mutable), although modules -such as L<Tie::File> can fake it. - -A Perl program to do these tasks takes the basic form of opening a -file, printing its lines, then closing the file: - - open my $in, '<', $file or die "Can't read old file: $!"; - open my $out, '>', "$file.new" or die "Can't write new file: $!"; - - while( <$in> ) { - print $out $_; - } - - close $out; - -Within that basic form, add the parts that you need to insert, change, -or delete lines. - -To prepend lines to the beginning, print those lines before you enter -the loop that prints the existing lines. - - open my $in, '<', $file or die "Can't read old file: $!"; - open my $out, '>', "$file.new" or die "Can't write new file: $!"; - - print $out "# Add this line to the top\n"; # <--- HERE'S THE MAGIC - - while( <$in> ) { - print $out $_; - } - - close $out; - -To change existing lines, insert the code to modify the lines inside -the C<while> loop. In this case, the code finds all lowercased -versions of "perl" and uppercases them. The happens for every line, so -be sure that you're supposed to do that on every line! - - open my $in, '<', $file or die "Can't read old file: $!"; - open my $out, '>', "$file.new" or die "Can't write new file: $!"; - - print $out "# Add this line to the top\n"; - - while( <$in> ) { - s/\b(perl)\b/Perl/g; - print $out $_; - } - - close $out; - -To change only a particular line, the input line number, C<$.>, is -useful. First read and print the lines up to the one you want to -change. Next, read the single line you want to change, change it, and -print it. After that, read the rest of the lines and print those: - - while( <$in> ) { # print the lines before the change - print $out $_; - last if $. == 4; # line number before change - } - - my $line = <$in>; - $line =~ s/\b(perl)\b/Perl/g; - print $out $line; - - while( <$in> ) { # print the rest of the lines - print $out $_; - } - -To skip lines, use the looping controls. The C<next> in this example -skips comment lines, and the C<last> stops all processing once it -encounters either C<__END__> or C<__DATA__>. - - while( <$in> ) { - next if /^\s+#/; # skip comment lines - last if /^__(END|DATA)__$/; # stop at end of code marker - print $out $_; - } - -Do the same sort of thing to delete a particular line by using C<next> -to skip the lines you don't want to show up in the output. This -example skips every fifth line: - - while( <$in> ) { - next unless $. % 5; - print $out $_; - } - -If, for some odd reason, you really want to see the whole file at once -rather than processing line-by-line, you can slurp it in (as long as -you can fit the whole thing in memory!): - - open my $in, '<', $file or die "Can't read old file: $!" - open my $out, '>', "$file.new" or die "Can't write new file: $!"; - - my @lines = do { local $/; <$in> }; # slurp! - - # do your magic here - - print $out @lines; - -Modules such as L<File::Slurp> and L<Tie::File> can help with that -too. If you can, however, avoid reading the entire file at once. Perl -won't give that memory back to the operating system until the process -finishes. - -You can also use Perl one-liners to modify a file in-place. The -following changes all 'Fred' to 'Barney' in F<inFile.txt>, overwriting -the file with the new contents. With the C<-p> switch, Perl wraps a -C<while> loop around the code you specify with C<-e>, and C<-i> turns -on in-place editing. The current line is in C<$_>. With C<-p>, Perl -automatically prints the value of C<$_> at the end of the loop. See -L<perlrun> for more details. - - perl -pi -e 's/Fred/Barney/' inFile.txt - -To make a backup of C<inFile.txt>, give C<-i> a file extension to add: - - perl -pi.bak -e 's/Fred/Barney/' inFile.txt - -To change only the fifth line, you can add a test checking C<$.>, the -input line number, then only perform the operation when the test -passes: - - perl -pi -e 's/Fred/Barney/ if $. == 5' inFile.txt - -To add lines before a certain line, you can add a line (or lines!) -before Perl prints C<$_>: - - perl -pi -e 'print "Put before third line\n" if $. == 3' inFile.txt - -You can even add a line to the beginning of a file, since the current -line prints at the end of the loop: - - perl -pi -e 'print "Put before first line\n" if $. == 1' inFile.txt - -To insert a line after one already in the file, use the C<-n> switch. -It's just like C<-p> except that it doesn't print C<$_> at the end of -the loop, so you have to do that yourself. In this case, print C<$_> -first, then print the line that you want to add. - - perl -ni -e 'print; print "Put after fifth line\n" if $. == 5' inFile.txt - -To delete lines, only print the ones that you want. - - perl -ni -e 'print if /d/' inFile.txt - -=head2 How do I count the number of lines in a file? -X<file, counting lines> X<lines> X<line> - -(contributed by brian d foy) - -Conceptually, the easiest way to count the lines in a file is to -simply read them and count them: - - my $count = 0; - while( <$fh> ) { $count++; } - -You don't really have to count them yourself, though, since Perl -already does that with the C<$.> variable, which is the current line -number from the last filehandle read: - - 1 while( <$fh> ); - my $count = $.; - -If you want to use C<$.>, you can reduce it to a simple one-liner, -like one of these: - - % perl -lne '} print $.; {' file - - % perl -lne 'END { print $. }' file - -Those can be rather inefficient though. If they aren't fast enough for -you, you might just read chunks of data and count the number of -newlines: - - my $lines = 0; - open my($fh), '<:raw', $filename or die "Can't open $filename: $!"; - while( sysread $fh, $buffer, 4096 ) { - $lines += ( $buffer =~ tr/\n// ); - } - close FILE; - -However, that doesn't work if the line ending isn't a newline. You -might change that C<tr///> to a C<s///> so you can count the number of -times the input record separator, C<$/>, shows up: - - my $lines = 0; - open my($fh), '<:raw', $filename or die "Can't open $filename: $!"; - while( sysread $fh, $buffer, 4096 ) { - $lines += ( $buffer =~ s|$/||g; ); - } - close FILE; - -If you don't mind shelling out, the C<wc> command is usually the -fastest, even with the extra interprocess overhead. Ensure that you -have an untainted filename though: - - #!perl -T - - $ENV{PATH} = undef; - - my $lines; - if( $filename =~ /^([0-9a-z_.]+)\z/ ) { - $lines = `/usr/bin/wc -l $1` - chomp $lines; - } - -=head2 How do I delete the last N lines from a file? -X<lines> X<file> - -(contributed by brian d foy) - -The easiest conceptual solution is to count the lines in the -file then start at the beginning and print the number of lines -(minus the last N) to a new file. - -Most often, the real question is how you can delete the last N lines -without making more than one pass over the file, or how to do it -without a lot of copying. The easy concept is the hard reality when -you might have millions of lines in your file. - -One trick is to use L<File::ReadBackwards>, which starts at the end of -the file. That module provides an object that wraps the real filehandle -to make it easy for you to move around the file. Once you get to the -spot you need, you can get the actual filehandle and work with it as -normal. In this case, you get the file position at the end of the last -line you want to keep and truncate the file to that point: - - use File::ReadBackwards; - - my $filename = 'test.txt'; - my $Lines_to_truncate = 2; - - my $bw = File::ReadBackwards->new( $filename ) - or die "Could not read backwards in [$filename]: $!"; - - my $lines_from_end = 0; - until( $bw->eof or $lines_from_end == $Lines_to_truncate ) { - print "Got: ", $bw->readline; - $lines_from_end++; - } - - truncate( $filename, $bw->tell ); - -The L<File::ReadBackwards> module also has the advantage of setting -the input record separator to a regular expression. - -You can also use the L<Tie::File> module which lets you access -the lines through a tied array. You can use normal array operations -to modify your file, including setting the last index and using -C<splice>. - -=head2 How can I use Perl's C<-i> option from within a program? -X<-i> X<in-place> - -C<-i> sets the value of Perl's C<$^I> variable, which in turn affects -the behavior of C<< <> >>; see L<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<.c> files in the current directory, -leaving a backup of the original data from each file in a new -C<.c.orig> file. - -=head2 How can I copy a file? -X<copy> X<file, copy> X<File::Copy> - -(contributed by brian d foy) - -Use the L<File::Copy> module. It comes with Perl and can do a -true copy across file systems, and it does its magic in -a portable fashion. - - use File::Copy; - - copy( $original, $new_copy ) or die "Copy failed: $!"; - -If you can't use L<File::Copy>, you'll have to do the work yourself: -open the original file, open the destination file, then print -to the destination file as you read the original. You also have to -remember to copy the permissions, owner, and group to the new file. - -=head2 How do I make a temporary file name? -X<file, temporary> - -If you don't need to know the name of the file, you can use C<open()> -with C<undef> in place of the file name. In Perl 5.8 or later, the -C<open()> function creates an anonymous temporary file: - - open my $tmp, '+>', undef or die $!; - -Otherwise, you can use the File::Temp module. - - use File::Temp qw/ tempfile tempdir /; - - my $dir = tempdir( CLEANUP => 1 ); - ($fh, $filename) = tempfile( DIR => $dir ); - - # or if you don't need to know the filename - - my $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; - my $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 { - 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 { - my $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) ) { - return ($fh, $base_name); - } - else { - return (); - } - } - } - -=head2 How can I manipulate fixed-record-length files? -X<fixed-length> X<file, fixed-length records> - -The most efficient way is using L<pack()|perlfunc/"pack"> and -L<unpack()|perlfunc/"unpack">. This is faster than using -L<substr()|perlfunc/"substr"> when taking many, many strings. It is -slower for just a few. - -Here is a sample chunk of code to break up and put back together again -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, $_); - for my $field ( @fields ) { - 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 makes it easy to operate on them as a -group or loop over them with C<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? -X<filehandle, local> X<filehandle, passing> X<filehandle, reference> - -As of perl5.6, open() autovivifies file and directory handles -as references if you pass it an uninitialized scalar variable. -You can then pass these references just like any other scalar, -and use them in the place of named handles. - - open my $fh, $file_name; - - open local $fh, $file_name; - - print $fh "Hello World!\n"; - - 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. - - open FILE, "> $filename"; - process_typeglob( *FILE ); - process_reference( \*FILE ); - - sub process_typeglob { local *FH = shift; print FH "Typeglob!" } - sub process_reference { local $fh = shift; print $fh "Reference!" } - -If you want to create many anonymous handles, you should -check out the Symbol or IO::Handle modules. - -=head2 How can I use a filehandle indirectly? -X<filehandle, indirect> - -An indirect filehandle is the use of something other than a symbol -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 - -Or, you can use the C<new> method from one of the IO::* modules to -create an anonymous filehandle and store that in a scalar variable. - - use IO::Handle; # 5.004 or higher - my $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 -instead. An indirect filehandle is just a scalar variable that contains -a filehandle. Functions like C<print>, C<open>, C<seek>, or -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: "; - my $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"; - } - -Or it can localize a typeglob and use the filehandle directly: - - 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); - -In the examples above, we assigned the filehandle to a scalar variable -before using it. That is because only simple scalar variables, not -expressions or subscripts of hashes or arrays, can be used with -built-ins like C<print>, C<printf>, or the diamond operator. Using -something other than a simple scalar variable as a filehandle is -illegal and won't even compile: - - my @fd = (*STDIN, *STDOUT, *STDERR); - print $fd[1] "Type it: "; # WRONG - my $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. - -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: - - my $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 -real operator, not just a function with a comma-less argument. Assuming -you've been storing typeglobs in your structure as we did above, you -can use the built-in function named C<readline> to read a record just -as C<< <> >> does. Given the initialization shown above for @fd, this -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]); - -Let it be noted that the flakiness of indirect filehandles is not -related to whether they're strings, typeglobs, objects, or anything else. -It's the syntax of the fundamental operators. Playing the object -game doesn't help you at all here. - -=head2 How can I set up a footer format to be used with write()? -X<footer> - -There's no builtin way to do this, but L<perlform> has a couple of -techniques to make it possible for the intrepid hacker. - -=head2 How can I write() into a string? -X<write, into a string> - -(contributed by brian d foy) - -If you want to C<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: C<$^>, which -names the top-of-page format, and C<$~> 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 C<formline> and the -accumulator variable C<$^A>, but you lose a lot of the value of formats -since C<formline> won't handle paging and so on. You end up reimplementing -formats when you use them. - -=head2 How can I open a filehandle to a string? -X<string> X<open> X<IO::String> X<filehandle> - -(contributed by Peter J. Holzer, hjp-usenet2@hjp.at) - -Since Perl 5.8.0 a file handle referring to a string can be created by -calling open with a reference to that string instead of the filename. -This file handle can then be used to read from or write to the string: - - open(my $fh, '>', \$string) or die "Could not open string for writing"; - print $fh "foo\n"; - print $fh "bar\n"; # $string now contains "foo\nbar\n" - - open(my $fh, '<', \$string) or die "Could not open string for reading"; - my $x = <$fh>; # $x now contains "foo\n" - -With older versions of Perl, the L<IO::String> module provides similar -functionality. - -=head2 How can I output my numbers with commas added? -X<number, commify> - -(contributed by brian d foy and Benjamin Goldberg) - -You can use L<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; - -=head2 How can I translate tildes (~) in a filename? -X<tilde> X<tilde expansion> - -Use the E<lt>E<gt> (C<glob()>) operator, documented in L<perlfunc>. -Versions of Perl older than 5.6 require that you have a shell -installed that groks tildes. Later versions of Perl have this feature -built in. The L<File::KGlob> module (available from CPAN) gives more -portable glob functionality. - -Within Perl, you may use this directly: - - $filename =~ s{ - ^ ~ # find a leading tilde - ( # save this in $1 - [^/] # a non-slash character - * # repeated 0 or more times (0 means me) - ) - }{ - $1 - ? (getpwnam($1))[7] - : ( $ENV{HOME} || $ENV{LOGDIR} ) - }ex; - -=head2 How come when I open a file read-write it wipes it out? -X<clobber> X<read-write> X<clobbering> X<truncate> X<truncating> - -Because you're using something like this, which truncates the file -I<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 C<sysopen> -all assume that you've pulled in the constants from L<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 L<perlopentut>. - -=head2 Why do I sometimes get an "Argument list too long" when I use E<lt>*E<gt>? -X<argument list too long> - -The C<< <> >> operator performs a globbing operation (see above). -In Perl versions earlier than v5.6.0, the internal glob() operator forks -csh(1) to do the actual glob expansion, but -csh can't handle more than 127 items and so gives the error message -C<Argument list too long>. People who installed tcsh as csh won't -have this problem, but their users may be surprised by it. - -To get around this, either upgrade to Perl v5.6.0 or later, do the glob -yourself with readdir() and patterns, or use a module like L<File::Glob>, -one that doesn't use the shell to do globbing. - -=head2 How can I open a file with a leading ">" or trailing blanks? -X<filename, special characters> - -(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" - -=head2 How can I reliably rename a file? -X<rename> X<mv> X<move> X<file, rename> - -If your operating system supports a proper mv(1) utility or its -functional equivalent, this works: - - rename($old, $new) or system("mv", $old, $new); - -It may be more portable to use the L<File::Copy> module instead. -You just copy to the new file to the new name (checking return -values), then delete the old one. This isn't really the same -semantically as a C<rename()>, which preserves meta-information like -permissions, timestamps, inode info, etc. - -=head2 How can I lock a file? -X<lock> X<file, lock> X<flock> - -Perl's builtin flock() function (see L<perlfunc> for details) will call -flock(2) if that exists, fcntl(2) if it doesn't (on perl version 5.004 and -later), and lockf(3) if neither of the two previous system calls exists. -On some systems, it may even use a different form of native locking. -Here are some gotchas with Perl's flock(): - -=over 4 - -=item 1 - -Produces a fatal error if none of the three system calls (or their -close equivalent) exists. - -=item 2 - -lockf(3) does not provide shared locking, and requires that the -filehandle be open for writing (or appending, or read/writing). - -=item 3 - -Some versions of flock() can't lock files over a network (e.g. on NFS file -systems), so you'd need to force the use of fcntl(2) when you build Perl. -But even this is dubious at best. See the flock entry of L<perlfunc> -and the F<INSTALL> file in the source distribution for information on -building Perl to do this. - -Two potentially non-obvious but traditional flock semantics are that -it waits indefinitely until the lock is granted, and that its locks are -I<merely advisory>. Such discretionary locks are more flexible, but -offer fewer guarantees. This means that files locked with flock() may -be modified by programs that do not also use flock(). Cars that stop -for red lights get on well with each other, but not with cars that don't -stop for red lights. See the perlport manpage, your port's specific -documentation, or your system-specific local manpages for details. It's -best to assume traditional behavior if you're writing portable programs. -(If you're not, you should as always feel perfectly free to write -for your own system's idiosyncrasies (sometimes called "features"). -Slavish adherence to portability concerns shouldn't get in the way of -your getting your job done.) - -For more information on file locking, see also -L<perlopentut/"File Locking"> if you have it (new for 5.6). - -=back - -=head2 Why can't I just open(FH, "E<gt>file.lock")? -X<lock, lockfile race condition> - -A common bit of code B<NOT TO USE> is this: - - sleep(3) while -e 'file.lock'; # PLEASE DO NOT USE - open my $lock, '>', '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 my $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 -over NFS, so this won't work (at least, not every time) over the net. -Various schemes involving link() have been suggested, but -these tend to involve busy-wait, which is also less than desirable. - -=head2 I still don't get locking. I just want to increment the number in the file. How can I do this? -X<counter> X<file, counter> - -Didn't anyone ever tell you web-page hit counters were useless? -They don't count number of hits, they're a waste of time, and they serve -only to stroke the writer's vanity. It's better to pick a random number; -they're more realistic. - -Anyway, this is what you can do if you can't help yourself. - - use Fcntl qw(:DEFAULT :flock); - sysopen my $fh, "numfile", O_RDWR|O_CREAT or die "can't open numfile: $!"; - flock $fh, LOCK_EX or die "can't flock numfile: $!"; - my $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) ); - -If the count doesn't impress your friends, then the code might. :-) - -=head2 All I want to do is append a small amount of text to the end of a file. Do I still have to use locking? -X<append> X<file, append> - -If you are on a system that correctly implements C<flock> and you use -the example appending code from "perldoc -f flock" everything will be -OK even if the OS you are on doesn't implement append mode correctly -(if such a system exists). So if you are happy to restrict yourself to -OSs that implement C<flock> (and that's not really much of a -restriction) then that is what you should do. - -If you know you are only going to use a system that does correctly -implement appending (i.e. not Win32) then you can omit the C<seek> -from the code in the previous answer. - -If you know you are only writing code to run on an OS and filesystem -that does implement append mode correctly (a local filesystem on a -modern Unix for example), and you keep the file in block-buffered mode -and you write less than one buffer-full of output between each manual -flushing of the buffer then each bufferload is almost guaranteed to be -written to the end of the file in one chunk without getting -intermingled with anyone else's output. You can also use the -C<syswrite> function which is simply a wrapper around your system's -C<write(2)> system call. - -There is still a small theoretical chance that a signal will interrupt -the system-level C<write()> operation before completion. There is also -a possibility that some STDIO implementations may call multiple system -level C<write()>s even if the buffer was empty to start. There may be -some systems where this probability is reduced to zero, and this is -not a concern when using C<:perlio> instead of your system's STDIO. - -=head2 How do I randomly update a binary file? -X<file, binary patch> - -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 - -However, if you have fixed sized records, then you might do something more -like this: - - my $RECSIZE = 220; # size of record, in bytes - my $recno = 37; # which record to update - open my $fh, '+<', 'somewhere' or die "can't update somewhere: $!"; - seek $fh, $recno * $RECSIZE, 0; - read $fh, $record, $RECSIZE == $RECSIZE or 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. - -=head2 How do I get a file's timestamp in perl? -X<timestamp> X<file, timestamp> - -If you want to retrieve the time at which the file was last read, -written, or had its meta-data (owner, etc) changed, you use the B<-A>, -B<-M>, or B<-C> file test operations as documented in L<perlfunc>. -These retrieve the age of the file (measured against the start-time of -your program) in days as a floating point number. Some platforms may -not have all of these times. See L<perlport> for details. To retrieve -the "raw" time in seconds since the epoch, you would call the stat -function, then use C<localtime()>, C<gmtime()>, or -C<POSIX::strftime()> to convert this into human-readable form. - -Here's an example: - - my $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; - my $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> -for details. - -=head2 How do I set a file's timestamp in perl? -X<timestamp> X<file, timestamp> - -You use the utime() function documented in L<perlfunc/utime>. -By way of example, here's a little program that copies the -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"; - } - my $timestamp = shift; - my($atime, $mtime) = (stat($timestamp))[8,9]; - utime $atime, $mtime, @ARGV; - -Error checking is, as usual, left as an exercise for the reader. - -The perldoc for utime also has an example that has the same -effect as touch(1) on files that I<already exist>. - -Certain file systems have a limited ability to store the times -on a file at the expected level of precision. For example, the -FAT and HPFS filesystem are unable to create dates on files with -a finer granularity than two seconds. This is a limitation of -the filesystems, not of utime(). - -=head2 How do I print to more than one file at once? -X<print, to multiple files> - -To connect one filehandle to several output filehandles, -you can use the L<IO::Tee> or L<Tie::FileHandle::Multiplex> modules. - -If you only have to do this once, you can print individually -to each filehandle. - - for my $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> - -The customary Perl approach for processing all the lines in a file is to -do so one line at a time: - - open my $input, '<', $file or die "can't open $file: $!"; - while (<$input>) { - chomp; - # do something with $_ - } - close $input or 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: - - my @lines = <INPUT>; - -You should think long and hard about why you need everything loaded at -once. It's just not a scalable solution. - -If you "mmap" the file with the File::Map module from -CPAN, you can virtually load the entire file into a -string without actually storing it in memory: - - use File::Map qw(map_file); - - map_file my $string, $filename; - -Once mapped, you can treat C<$string> as you would any other string. -Since you don't necessarily have to load the data, mmap-ing can be -very fast and may not increase your memory footprint. - -You might also find it more -fun to use the standard L<Tie::File> module, or the L<DB_File> module's -C<$DB_RECNO> bindings, which allow you to tie an array to a file so that -accessing an element of the array actually accesses the corresponding -line in the file. - -If you want to load the entire file, you can use the L<File::Slurp> -module to do it in one one simple and efficient step: - - use File::Slurp; - - my $all_of_it = read_file($filename); # entire file in scalar - my @all_lines = read_file($filename); # one line per element - -Or you can read the entire file contents into a scalar like this: - - my $var; - { - local $/; - open my $fh, '<', $file or die "can't open $file: $!"; - $var = <$fh>; - } - -That temporarily undefs your record separator, and will automatically -close the file at block exit. If the file is already open, just use this: - - my $var = do { local $/; <$fh> }; - -You can also use a localized C<@ARGV> to eliminate the C<open>: - - my $var = do { local( @ARGV, $/ ) = $file; <> }; - -For ordinary files you can also use the C<read> function. - - read( $fh, $var, -s $fh ); - -That third argument tests the byte size of the data on the C<$fh> filehandle -and reads that many bytes into the buffer C<$var>. - -=head2 How can I read in a file by paragraphs? -X<file, reading by paragraphs> - -Use the C<$/> variable (see L<perlvar> for details). You can either -set it to C<""> to eliminate empty paragraphs (C<"abc\n\n\n\ndef">, -for instance, gets treated as two paragraphs and not three), or -C<"\n\n"> to accept empty paragraphs. - -Note that a blank line must have no blanks in it. Thus -S<C<"fred\n \nstuff\n\n">> is one paragraph, but C<"fred\n\nstuff\n\n"> is two. - -=head2 How can I read a single character from a file? From the keyboard? -X<getc> X<file, reading one character at a time> - -You can use the builtin C<getc()> function for most filehandles, but -it won't (easily) work on a terminal device. For STDIN, either use -the Term::ReadKey module from CPAN or use the sample code in -L<perlfunc/getc>. - -If your system supports the portable operating system programming -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) { - print "gimme: "; - my $got = getone(); - print "--> $got\n"; - } - exit; - - BEGIN { - use POSIX qw(:termios_h); - - my ($term, $oterm, $echo, $noecho, $fd_stdin); - - my $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); - $term->setcc(VTIME, 1); - $term->setattr($fd_stdin, TCSANOW); - } - - sub cooked { - $term->setlflag($oterm); - $term->setcc(VTIME, 0); - $term->setattr($fd_stdin, TCSANOW); - } - - sub getone { - my $key = ''; - cbreak(); - sysread(STDIN, $key, 1); - cooked(); - return $key; - } - } - - 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 my $tty, '<', '/dev/tty'; - print "Gimme a char: "; - ReadMode "raw"; - my $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? - -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 I<h2ph> tool that -comes with Perl tries to convert C include files to Perl code, which -can be C<require>d. FIONREAD ends up defined as a function in the -I<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 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 - -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 I<not> files. - -=head2 How do I do a C<tail -f> in perl? -X<tail> X<IO::Handle> X<File::Tail> X<clearerr> - -First try - - seek($gw_fh, 0, 1); - -The statement C<seek($gw_fh, 0, 1)> doesn't change the current position, -but it does clear the end-of-file condition on the handle, so that the -next C<< <$gw_fh> >> makes Perl try again to read something. - -If that doesn't work (it relies on features of your stdio implementation), -then you need something more like this: - - for (;;) { - for ($curpos = tell($gw_fh); <$gw_fh>; $curpos =tell($gw_fh)) { - # search for some stuff and put it into files - } - # sleep for a while - seek($gw_fh, $curpos, 0); # seek to where we had been - } - -If this still doesn't work, look into the C<clearerr> method -from L<IO::Handle>, which resets the error and end-of-file states -on the handle. - -There's also a L<File::Tail> module from CPAN. - -=head2 How do I dup() a filehandle in Perl? -X<dup> - -If you check L<perlfunc/open>, you'll see that several of the ways -to call open() should do the trick. For example: - - open my $log, '>>', '/foo/logfile'; - open STDERR, '>&', $log; - -Or even with a literal numeric descriptor: - - my $fd = $ENV{MHCONTEXTFD}; - open $mhcontext, "<&=$fd"; # like fdopen(3S) - -Note that "<&STDIN" makes a copy, but "<&=STDIN" makes -an alias. That means if you close an aliased handle, all -aliases become inaccessible. This is not true with -a copied one. - -Error checking, as always, has been left as an exercise for the reader. - -=head2 How do I close a file descriptor by number? -X<file, closing file descriptors> X<POSIX> X<close> - -If, for some reason, you have a file descriptor instead of a -filehandle (perhaps you used C<POSIX::open>), you can use the -C<close()> function from the L<POSIX> module: - - use POSIX (); - - POSIX::close( $fd ); - -This should rarely be necessary, as the Perl C<close()> function is to be -used for things that Perl opened itself, even if it was a dup of a -numeric descriptor as with C<MHCONTEXT> above. But if you really have -to, you may be able to do this: - - require 'sys/syscall.ph'; - my $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 C<open()>: - - { - open my $fh, "<&=$fd" or die "Cannot reopen fd=$fd: $!"; - close $fh; - } - -=head2 Why can't I use "C:\temp\foo" in DOS paths? Why doesn't `C:\temp\foo.exe` work? -X<filename, DOS issues> - -Whoops! You just put a tab and a formfeed into that filename! -Remember that within double quoted strings ("like\this"), the -backslash is an escape character. The full list of these is in -L<perlop/Quote and Quote-like Operators>. Unsurprisingly, you don't -have a file called "c:(tab)emp(formfeed)oo" or -"c:(tab)emp(formfeed)oo.exe" on your legacy DOS filesystem. - -Either single-quote your strings, or (preferably) use forward slashes. -Since all DOS and Windows versions since something like MS-DOS 2.0 or so -have treated C</> and C<\> the same in a path, you might as well use the -one that doesn't clash with Perl--or the POSIX shell, ANSI C and C++, -awk, Tcl, Java, or Python, just to mention a few. POSIX paths -are more portable, too. - -=head2 Why doesn't glob("*.*") get all the files? -X<glob> - -Because even on non-Unix ports, Perl's glob function follows standard -Unix globbing semantics. You'll need C<glob("*")> to get all (non-hidden) -files. This makes glob() portable even to legacy systems. Your -port may include proprietary globbing functions as well. Check its -documentation for details. - -=head2 Why does Perl let me delete read-only files? Why does C<-i> clobber protected files? Isn't this a bug in Perl? - -This is elaborately and painstakingly described in the -F<file-dir-perms> article in the "Far More Than You Ever Wanted To -Know" collection in L<http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz> . - -The executive summary: learn how your filesystem works. The -permissions on a file say what can happen to the data in that file. -The permissions on a directory say what can happen to the list of -files in that directory. If you delete a file, you're removing its -name from the directory (so the operation depends on the permissions -of the directory, not of the file). If you try to write to the file, -the permissions of the file govern whether you're allowed to. - -=head2 How do I select a random line from a file? -X<file, selecting a random line> - -Short of loading the file into a database or pre-indexing the lines in -the file, there are a couple of things that you can do. - -Here's a reservoir-sampling algorithm from the Camel Book: - - 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 -Programming>, Volume 2, Section 3.4.2, by Donald E. Knuth. - -You can use the L<File::Random> module which provides a function -for that algorithm: - - use File::Random qw/random_line/; - my $line = random_line($filename); - -Another way is to use the L<Tie::File> module, which treats the entire -file as an array. Simply access a random array element. - -=head2 Why do I get weird spaces when I print an array of lines? - -(contributed by brian d foy) - -If you are seeing spaces between the elements of your array when -you print the array, you are probably interpolating the array in -double quotes: - - my @animals = qw(camel llama alpaca vicuna); - print "animals are: @animals\n"; - -It's the double quotes, not the C<print>, doing this. Whenever you -interpolate an array in a double quote context, Perl joins the -elements with spaces (or whatever is in C<$">, which is a space by -default): - - animals are: camel llama alpaca vicuna - -This is different than printing the array without the interpolation: - - my @animals = qw(camel llama alpaca vicuna); - print "animals are: ", @animals, "\n"; - -Now the output doesn't have the spaces between the elements because -the elements of C<@animals> simply become part of the list to -C<print>: - - animals are: camelllamaalpacavicuna - -You might notice this when each of the elements of C<@array> end with -a newline. You expect to print one element per line, but notice that -every line after the first is indented: - - this is a line - this is another line - this is the third line - -That extra space comes from the interpolation of the array. If you -don't want to put anything between your array elements, don't use the -array in double quotes. You can send it to print without them: - - print @lines; - -=head2 How do I traverse a directory tree? - -(contributed by brian d foy) - -The L<File::Find> module, which comes with Perl, does all of the hard -work to traverse a directory structure. It comes with Perl. You simply -call the C<find> subroutine with a callback subroutine and the -directories you want to traverse: - - use File::Find; - - find( \&wanted, @directories ); - - sub wanted { - # full path in $File::Find::name - # just filename in $_ - ... do whatever you want to do ... - } - -The L<File::Find::Closures>, which you can download from CPAN, provides -many ready-to-use subroutines that you can use with L<File::Find>. - -The L<File::Finder>, which you can download from CPAN, can help you -create the callback subroutine using something closer to the syntax of -the C<find> command-line utility: - - use File::Find; - use File::Finder; - - my $deep_dirs = File::Finder->depth->type('d')->ls->exec('rmdir','{}'); - - find( $deep_dirs->as_options, @places ); - -The L<File::Find::Rule> module, which you can download from CPAN, has -a similar interface, but does the traversal for you too: - - use File::Find::Rule; - - my @files = File::Find::Rule->file() - ->name( '*.pm' ) - ->in( @INC ); - -=head2 How do I delete a directory tree? - -(contributed by brian d foy) - -If you have an empty directory, you can use Perl's built-in C<rmdir>. -If the directory is not empty (so, no files or subdirectories), you -either have to empty it yourself (a lot of work) or use a module to -help you. - -The L<File::Path> module, which comes with Perl, has a C<remove_tree> -which can take care of all of the hard work for you: - - use File::Path qw(remove_tree); - - remove_tree( @directories ); - -The L<File::Path> module also has a legacy interface to the older -C<rmtree> subroutine. - -=head2 How do I copy an entire directory? - -(contributed by Shlomi Fish) - -To do the equivalent of C<cp -R> (i.e. copy an entire directory tree -recursively) in portable Perl, you'll either need to write something yourself -or find a good CPAN module such as L<File::Copy::Recursive>. - -=head1 AUTHOR AND COPYRIGHT - -Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington, and -other authors as noted. All rights reserved. - -This documentation is free; you can redistribute it and/or modify it -under the same terms as Perl itself. - -Irrespective of its distribution, all code examples here are in the public -domain. You are permitted and encouraged to use this code and any -derivatives thereof in your own programs for fun or for profit as you -see fit. A simple comment in the code giving credit to the FAQ would -be courteous but is not required. |