Commit | Line | Data |
---|---|---|
68dc0745 | 1 | =head1 NAME |
2 | ||
109f0441 | 3 | perlfaq5 - Files and Formats |
68dc0745 | 4 | |
5 | =head1 DESCRIPTION | |
6 | ||
7 | This section deals with I/O and the "f" issues: filehandles, flushing, | |
8 | formats, and footers. | |
9 | ||
5a964f20 | 10 | =head2 How do I flush/unbuffer an output filehandle? Why must I do this? |
d74e8afc | 11 | X<flush> X<buffer> X<unbuffer> X<autoflush> |
68dc0745 | 12 | |
109f0441 | 13 | (contributed by brian d foy) |
5a964f20 | 14 | |
109f0441 S |
15 | You might like to read Mark Jason Dominus's "Suffering From Buffering" |
16 | at http://perl.plover.com/FAQs/Buffering.html . | |
68dc0745 | 17 | |
109f0441 S |
18 | Perl normally buffers output so it doesn't make a system call for every |
19 | bit of output. By saving up output, it makes fewer expensive system calls. | |
20 | For instance, in this little bit of code, you want to print a dot to the | |
21 | screen for every line you process to watch the progress of your program. | |
22 | Instead of seeing a dot for every line, Perl buffers the output and you | |
23 | have a long wait before you see a row of 50 dots all at once: | |
24 | ||
25 | # long wait, then row of dots all at once | |
26 | while( <> ) { | |
27 | print "."; | |
28 | print "\n" unless ++$count % 50; | |
29 | ||
30 | #... expensive line processing operations | |
31 | } | |
32 | ||
33 | To get around this, you have to unbuffer the output filehandle, in this | |
34 | case, C<STDOUT>. You can set the special variable C<$|> to a true value | |
35 | (mnemonic: making your filehandles "piping hot"): | |
36 | ||
37 | $|++; | |
38 | ||
39 | # dot shown immediately | |
40 | while( <> ) { | |
41 | print "."; | |
42 | print "\n" unless ++$count % 50; | |
43 | ||
44 | #... expensive line processing operations | |
45 | } | |
46 | ||
47 | The C<$|> is one of the per-filehandle special variables, so each | |
48 | filehandle has its own copy of its value. If you want to merge | |
49 | standard output and standard error for instance, you have to unbuffer | |
50 | each (although STDERR might be unbuffered by default): | |
51 | ||
52 | { | |
53 | my $previous_default = select(STDOUT); # save previous default | |
54 | $|++; # autoflush STDOUT | |
55 | select(STDERR); | |
56 | $|++; # autoflush STDERR, to be sure | |
57 | select($previous_default); # restore previous default | |
58 | } | |
68dc0745 | 59 | |
109f0441 S |
60 | # now should alternate . and + |
61 | while( 1 ) | |
62 | { | |
63 | sleep 1; | |
64 | print STDOUT "."; | |
65 | print STDERR "+"; | |
66 | print STDOUT "\n" unless ++$count % 25; | |
67 | } | |
68 | ||
69 | Besides the C<$|> special variable, you can use C<binmode> to give | |
70 | your filehandle a C<:unix> layer, which is unbuffered: | |
71 | ||
72 | binmode( STDOUT, ":unix" ); | |
68dc0745 | 73 | |
109f0441 S |
74 | while( 1 ) { |
75 | sleep 1; | |
76 | print "."; | |
77 | print "\n" unless ++$count % 50; | |
78 | } | |
68dc0745 | 79 | |
109f0441 S |
80 | For more information on output layers, see the entries for C<binmode> |
81 | and C<open> in L<perlfunc>, and the C<PerlIO> module documentation. | |
68dc0745 | 82 | |
109f0441 S |
83 | If you are using C<IO::Handle> or one of its subclasses, you can |
84 | call the C<autoflush> method to change the settings of the | |
85 | filehandle: | |
c195e131 RGS |
86 | |
87 | use IO::Handle; | |
109f0441 S |
88 | open my( $io_fh ), ">", "output.txt"; |
89 | $io_fh->autoflush(1); | |
90 | ||
91 | The C<IO::Handle> objects also have a C<flush> method. You can flush | |
92 | the buffer any time you want without auto-buffering | |
c195e131 | 93 | |
109f0441 | 94 | $io_fh->flush; |
487af187 | 95 | |
e573f903 | 96 | =head2 How do I change, delete, or insert a line in a file, or append to the beginning of a file? |
d74e8afc | 97 | X<file, editing> |
68dc0745 | 98 | |
e573f903 RGS |
99 | (contributed by brian d foy) |
100 | ||
101 | The basic idea of inserting, changing, or deleting a line from a text | |
102 | file involves reading and printing the file to the point you want to | |
103 | make the change, making the change, then reading and printing the rest | |
104 | of the file. Perl doesn't provide random access to lines (especially | |
105 | since the record input separator, C<$/>, is mutable), although modules | |
106 | such as C<Tie::File> can fake it. | |
107 | ||
108 | A Perl program to do these tasks takes the basic form of opening a | |
109 | file, printing its lines, then closing the file: | |
110 | ||
111 | open my $in, '<', $file or die "Can't read old file: $!"; | |
112 | open my $out, '>', "$file.new" or die "Can't write new file: $!"; | |
113 | ||
114 | while( <$in> ) | |
115 | { | |
116 | print $out $_; | |
117 | } | |
118 | ||
119 | close $out; | |
120 | ||
121 | Within that basic form, add the parts that you need to insert, change, | |
122 | or delete lines. | |
123 | ||
124 | To prepend lines to the beginning, print those lines before you enter | |
125 | the loop that prints the existing lines. | |
126 | ||
127 | open my $in, '<', $file or die "Can't read old file: $!"; | |
128 | open my $out, '>', "$file.new" or die "Can't write new file: $!"; | |
129 | ||
109f0441 | 130 | print $out "# Add this line to the top\n"; # <--- HERE'S THE MAGIC |
e573f903 RGS |
131 | |
132 | while( <$in> ) | |
133 | { | |
134 | print $out $_; | |
135 | } | |
136 | ||
137 | close $out; | |
138 | ||
139 | To change existing lines, insert the code to modify the lines inside | |
140 | the C<while> loop. In this case, the code finds all lowercased | |
141 | versions of "perl" and uppercases them. The happens for every line, so | |
142 | be sure that you're supposed to do that on every line! | |
143 | ||
144 | open my $in, '<', $file or die "Can't read old file: $!"; | |
145 | open my $out, '>', "$file.new" or die "Can't write new file: $!"; | |
146 | ||
109f0441 | 147 | print $out "# Add this line to the top\n"; |
e573f903 RGS |
148 | |
149 | while( <$in> ) | |
150 | { | |
151 | s/\b(perl)\b/Perl/g; | |
152 | print $out $_; | |
153 | } | |
154 | ||
155 | close $out; | |
156 | ||
157 | To change only a particular line, the input line number, C<$.>, is | |
ee891a00 RGS |
158 | useful. First read and print the lines up to the one you want to |
159 | change. Next, read the single line you want to change, change it, and | |
160 | print it. After that, read the rest of the lines and print those: | |
e573f903 | 161 | |
ee891a00 | 162 | while( <$in> ) # print the lines before the change |
e573f903 | 163 | { |
e573f903 | 164 | print $out $_; |
ee891a00 | 165 | last if $. == 4; # line number before change |
e573f903 RGS |
166 | } |
167 | ||
ee891a00 RGS |
168 | my $line = <$in>; |
169 | $line =~ s/\b(perl)\b/Perl/g; | |
170 | print $out $line; | |
171 | ||
172 | while( <$in> ) # print the rest of the lines | |
173 | { | |
174 | print $out $_; | |
175 | } | |
109f0441 | 176 | |
e573f903 RGS |
177 | To skip lines, use the looping controls. The C<next> in this example |
178 | skips comment lines, and the C<last> stops all processing once it | |
179 | encounters either C<__END__> or C<__DATA__>. | |
180 | ||
181 | while( <$in> ) | |
182 | { | |
183 | next if /^\s+#/; # skip comment lines | |
184 | last if /^__(END|DATA)__$/; # stop at end of code marker | |
185 | print $out $_; | |
186 | } | |
187 | ||
188 | Do the same sort of thing to delete a particular line by using C<next> | |
189 | to skip the lines you don't want to show up in the output. This | |
190 | example skips every fifth line: | |
191 | ||
192 | while( <$in> ) | |
193 | { | |
194 | next unless $. % 5; | |
195 | print $out $_; | |
196 | } | |
197 | ||
198 | If, for some odd reason, you really want to see the whole file at once | |
f12f5f55 | 199 | rather than processing line-by-line, you can slurp it in (as long as |
e573f903 RGS |
200 | you can fit the whole thing in memory!): |
201 | ||
202 | open my $in, '<', $file or die "Can't read old file: $!" | |
203 | open my $out, '>', "$file.new" or die "Can't write new file: $!"; | |
204 | ||
205 | my @lines = do { local $/; <$in> }; # slurp! | |
206 | ||
207 | # do your magic here | |
208 | ||
209 | print $out @lines; | |
210 | ||
211 | Modules such as C<File::Slurp> and C<Tie::File> can help with that | |
212 | too. If you can, however, avoid reading the entire file at once. Perl | |
213 | won't give that memory back to the operating system until the process | |
214 | finishes. | |
215 | ||
216 | You can also use Perl one-liners to modify a file in-place. The | |
217 | following changes all 'Fred' to 'Barney' in F<inFile.txt>, overwriting | |
218 | the file with the new contents. With the C<-p> switch, Perl wraps a | |
219 | C<while> loop around the code you specify with C<-e>, and C<-i> turns | |
220 | on in-place editing. The current line is in C<$_>. With C<-p>, Perl | |
221 | automatically prints the value of C<$_> at the end of the loop. See | |
222 | L<perlrun> for more details. | |
223 | ||
224 | perl -pi -e 's/Fred/Barney/' inFile.txt | |
225 | ||
226 | To make a backup of C<inFile.txt>, give C<-i> a file extension to add: | |
227 | ||
228 | perl -pi.bak -e 's/Fred/Barney/' inFile.txt | |
229 | ||
230 | To change only the fifth line, you can add a test checking C<$.>, the | |
231 | input line number, then only perform the operation when the test | |
232 | passes: | |
233 | ||
234 | perl -pi -e 's/Fred/Barney/ if $. == 5' inFile.txt | |
235 | ||
236 | To add lines before a certain line, you can add a line (or lines!) | |
237 | before Perl prints C<$_>: | |
238 | ||
239 | perl -pi -e 'print "Put before third line\n" if $. == 3' inFile.txt | |
240 | ||
241 | You can even add a line to the beginning of a file, since the current | |
242 | line prints at the end of the loop: | |
243 | ||
244 | perl -pi -e 'print "Put before first line\n" if $. == 1' inFile.txt | |
245 | ||
246 | To insert a line after one already in the file, use the C<-n> switch. | |
247 | It's just like C<-p> except that it doesn't print C<$_> at the end of | |
248 | the loop, so you have to do that yourself. In this case, print C<$_> | |
249 | first, then print the line that you want to add. | |
250 | ||
251 | perl -ni -e 'print; print "Put after fifth line\n" if $. == 5' inFile.txt | |
252 | ||
253 | To delete lines, only print the ones that you want. | |
254 | ||
255 | perl -ni -e 'print unless /d/' inFile.txt | |
256 | ||
257 | ... or ... | |
258 | ||
259 | perl -pi -e 'next unless /d/' inFile.txt | |
68dc0745 | 260 | |
261 | =head2 How do I count the number of lines in a file? | |
d74e8afc | 262 | X<file, counting lines> X<lines> X<line> |
68dc0745 | 263 | |
8d2e243f | 264 | (contributed by brian d foy) |
265 | ||
266 | Conceptually, the easiest way to count the lines in a file is to | |
267 | simply read them and count them: | |
268 | ||
269 | my $count = 0; | |
270 | while( <$fh> ) { $count++; } | |
271 | ||
272 | You don't really have to count them yourself, though, since Perl | |
273 | already does that with the C<$.> variable, which is the current line | |
274 | number from the last filehandle read: | |
275 | ||
276 | 1 while( <$fh> ); | |
277 | my $count = $.; | |
278 | ||
279 | If you want to use C<$.>, you can reduce it to a simple one-liner, | |
280 | like one of these: | |
281 | ||
282 | % perl -lne '} print $.; {' file | |
283 | ||
284 | % perl -lne 'END { print $. }' file | |
285 | ||
286 | Those can be rather inefficient though. If they aren't fast enough for | |
287 | you, you might just read chunks of data and count the number of | |
288 | newlines: | |
289 | ||
290 | my $lines = 0; | |
291 | open my($fh), '<:raw', $filename or die "Can't open $filename: $!"; | |
292 | while( sysread $fh, $buffer, 4096 ) { | |
293 | $lines += ( $buffer =~ tr/\n// ); | |
500071f4 RGS |
294 | } |
295 | close FILE; | |
68dc0745 | 296 | |
8d2e243f | 297 | However, that doesn't work if the line ending isn't a newline. You |
298 | might change that C<tr///> to a C<s///> so you can count the number of | |
299 | times the input record separator, C<$/>, shows up: | |
300 | ||
301 | my $lines = 0; | |
302 | open my($fh), '<:raw', $filename or die "Can't open $filename: $!"; | |
303 | while( sysread $fh, $buffer, 4096 ) { | |
304 | $lines += ( $buffer =~ s|$/||g; ); | |
305 | } | |
306 | close FILE; | |
307 | ||
308 | If you don't mind shelling out, the C<wc> command is usually the | |
309 | fastest, even with the extra interprocess overhead. Ensure that you | |
310 | have an untainted filename though: | |
311 | ||
312 | #!perl -T | |
d12d61cf | 313 | |
8d2e243f | 314 | $ENV{PATH} = undef; |
d12d61cf | 315 | |
8d2e243f | 316 | my $lines; |
317 | if( $filename =~ /^([0-9a-z_.]+)\z/ ) { | |
318 | $lines = `/usr/bin/wc -l $1` | |
319 | chomp $lines; | |
320 | } | |
5a964f20 | 321 | |
589a5df2 | 322 | =head2 How do I delete the last N lines from a file? |
323 | X<lines> X<file> | |
324 | ||
325 | (contributed by brian d foy) | |
326 | ||
d12d61cf | 327 | The easiest conceptual solution is to count the lines in the |
589a5df2 | 328 | file then start at the beginning and print the number of lines |
329 | (minus the last N) to a new file. | |
330 | ||
d12d61cf | 331 | Most often, the real question is how you can delete the last N lines |
332 | without making more than one pass over the file, or how to do it | |
333 | without a lot of copying. The easy concept is the hard reality when | |
589a5df2 | 334 | you might have millions of lines in your file. |
335 | ||
d12d61cf | 336 | One trick is to use C<File::ReadBackwards>, which starts at the end of |
589a5df2 | 337 | the file. That module provides an object that wraps the real filehandle |
d12d61cf | 338 | to make it easy for you to move around the file. Once you get to the |
589a5df2 | 339 | spot you need, you can get the actual filehandle and work with it as |
340 | normal. In this case, you get the file position at the end of the last | |
341 | line you want to keep and truncate the file to that point: | |
342 | ||
343 | use File::ReadBackwards; | |
d12d61cf | 344 | |
589a5df2 | 345 | my $filename = 'test.txt'; |
346 | my $Lines_to_truncate = 2; | |
347 | ||
d12d61cf | 348 | my $bw = File::ReadBackwards->new( $filename ) |
589a5df2 | 349 | or die "Could not read backwards in [$filename]: $!"; |
d12d61cf | 350 | |
589a5df2 | 351 | my $lines_from_end = 0; |
d12d61cf | 352 | until( $bw->eof or $lines_from_end == $Lines_to_truncate ) |
589a5df2 | 353 | { |
354 | print "Got: ", $bw->readline; | |
355 | $lines_from_end++; | |
356 | } | |
d12d61cf | 357 | |
589a5df2 | 358 | truncate( $filename, $bw->tell ); |
359 | ||
360 | The C<File::ReadBackwards> module also has the advantage of setting | |
361 | the input record separator to a regular expression. | |
362 | ||
363 | You can also use the C<Tie::File> module which lets you access | |
364 | the lines through a tied array. You can use normal array operations | |
d12d61cf | 365 | to modify your file, including setting the last index and using |
589a5df2 | 366 | C<splice>. |
367 | ||
4750257b | 368 | =head2 How can I use Perl's C<-i> option from within a program? |
d74e8afc | 369 | X<-i> X<in-place> |
4750257b MJD |
370 | |
371 | C<-i> sets the value of Perl's C<$^I> variable, which in turn affects | |
d12d61cf | 372 | the behavior of C<< <> >>; see L<perlrun> for more details. By |
4750257b | 373 | modifying the appropriate variables directly, you can get the same |
d12d61cf | 374 | behavior within a larger program. For example: |
4750257b | 375 | |
500071f4 RGS |
376 | # ... |
377 | { | |
378 | local($^I, @ARGV) = ('.orig', glob("*.c")); | |
379 | while (<>) { | |
380 | if ($. == 1) { | |
381 | print "This line should appear at the top of each file\n"; | |
382 | } | |
383 | s/\b(p)earl\b/${1}erl/i; # Correct typos, preserving case | |
384 | print; | |
385 | close ARGV if eof; # Reset $. | |
386 | } | |
387 | } | |
388 | # $^I and @ARGV return to their old values here | |
4750257b MJD |
389 | |
390 | This block modifies all the C<.c> files in the current directory, | |
391 | leaving a backup of the original data from each file in a new | |
392 | C<.c.orig> file. | |
393 | ||
7678cced | 394 | =head2 How can I copy a file? |
109f0441 | 395 | X<copy> X<file, copy> X<File::Copy> |
7678cced RGS |
396 | |
397 | (contributed by brian d foy) | |
398 | ||
109f0441 | 399 | Use the C<File::Copy> module. It comes with Perl and can do a |
7678cced RGS |
400 | true copy across file systems, and it does its magic in |
401 | a portable fashion. | |
402 | ||
403 | use File::Copy; | |
404 | ||
405 | copy( $original, $new_copy ) or die "Copy failed: $!"; | |
406 | ||
109f0441 | 407 | If you can't use C<File::Copy>, you'll have to do the work yourself: |
7678cced | 408 | open the original file, open the destination file, then print |
109f0441 S |
409 | to the destination file as you read the original. You also have to |
410 | remember to copy the permissions, owner, and group to the new file. | |
7678cced | 411 | |
68dc0745 | 412 | =head2 How do I make a temporary file name? |
d74e8afc | 413 | X<file, temporary> |
68dc0745 | 414 | |
7678cced | 415 | If you don't need to know the name of the file, you can use C<open()> |
d12d61cf | 416 | with C<undef> in place of the file name. In Perl 5.8 or later, the |
109f0441 | 417 | C<open()> function creates an anonymous temporary file: |
7678cced RGS |
418 | |
419 | open my $tmp, '+>', undef or die $!; | |
6670e5e7 | 420 | |
7678cced | 421 | Otherwise, you can use the File::Temp module. |
68dc0745 | 422 | |
500071f4 | 423 | use File::Temp qw/ tempfile tempdir /; |
a6dd486b | 424 | |
d12d61cf | 425 | my $dir = tempdir( CLEANUP => 1 ); |
500071f4 | 426 | ($fh, $filename) = tempfile( DIR => $dir ); |
5a964f20 | 427 | |
500071f4 | 428 | # or if you don't need to know the filename |
5a964f20 | 429 | |
d12d61cf | 430 | my $fh = tempfile( DIR => $dir ); |
5a964f20 | 431 | |
d12d61cf | 432 | The File::Temp has been a standard module since Perl 5.6.1. If you |
16394a69 JH |
433 | don't have a modern enough Perl installed, use the C<new_tmpfile> |
434 | class method from the IO::File module to get a filehandle opened for | |
d12d61cf | 435 | reading and writing. Use it if you don't need to know the file's name: |
5a964f20 | 436 | |
500071f4 | 437 | use IO::File; |
d12d61cf | 438 | my $fh = IO::File->new_tmpfile() |
439 | or die "Unable to make new temporary file: $!"; | |
5a964f20 | 440 | |
a6dd486b | 441 | If you're committed to creating a temporary file by hand, use the |
d12d61cf | 442 | process ID and/or the current time-value. If you need to have many |
a6dd486b | 443 | temporary files in one process, use a counter: |
5a964f20 | 444 | |
500071f4 | 445 | BEGIN { |
68dc0745 | 446 | use Fcntl; |
16394a69 | 447 | my $temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMPDIR} || $ENV{TEMP}; |
c195e131 | 448 | my $base_name = sprintf "%s/%d-%d-0000", $temp_dir, $$, time; |
500071f4 | 449 | |
68dc0745 | 450 | sub temp_file { |
71f155bf | 451 | my $fh; |
500071f4 | 452 | my $count = 0; |
71f155bf | 453 | until( defined(fileno($fh)) || $count++ > 100 ) { |
c195e131 RGS |
454 | $base_name =~ s/-(\d+)$/"-" . (1 + $1)/e; |
455 | # O_EXCL is required for security reasons. | |
71f155bf | 456 | sysopen $fh, $base_name, O_WRONLY|O_EXCL|O_CREAT; |
c195e131 RGS |
457 | } |
458 | ||
d12d61cf | 459 | if( defined fileno($fh) ) { |
460 | return ($fh, $base_name); | |
c195e131 RGS |
461 | } |
462 | else { | |
463 | return (); | |
464 | } | |
500071f4 | 465 | } |
109f0441 | 466 | |
500071f4 | 467 | } |
68dc0745 | 468 | |
68dc0745 | 469 | =head2 How can I manipulate fixed-record-length files? |
d74e8afc | 470 | X<fixed-length> X<file, fixed-length records> |
68dc0745 | 471 | |
793f5136 | 472 | The most efficient way is using L<pack()|perlfunc/"pack"> and |
d12d61cf | 473 | L<unpack()|perlfunc/"unpack">. This is faster than using |
474 | L<substr()|perlfunc/"substr"> when taking many, many strings. It is | |
793f5136 | 475 | slower for just a few. |
5a964f20 TC |
476 | |
477 | Here is a sample chunk of code to break up and put back together again | |
478 | some fixed-format input lines, in this case from the output of a normal, | |
479 | Berkeley-style ps: | |
68dc0745 | 480 | |
500071f4 RGS |
481 | # sample input line: |
482 | # 15158 p5 T 0:00 perl /home/tchrist/scripts/now-what | |
483 | my $PS_T = 'A6 A4 A7 A5 A*'; | |
484 | open my $ps, '-|', 'ps'; | |
485 | print scalar <$ps>; | |
486 | my @fields = qw( pid tt stat time command ); | |
487 | while (<$ps>) { | |
488 | my %process; | |
489 | @process{@fields} = unpack($PS_T, $_); | |
793f5136 | 490 | for my $field ( @fields ) { |
500071f4 | 491 | print "$field: <$process{$field}>\n"; |
68dc0745 | 492 | } |
793f5136 | 493 | print 'line=', pack($PS_T, @process{@fields} ), "\n"; |
500071f4 | 494 | } |
68dc0745 | 495 | |
793f5136 | 496 | We've used a hash slice in order to easily handle the fields of each row. |
09c1cbc2 FC |
497 | Storing the keys in an array makes it easy to operate on them as a |
498 | group or loop over them with C<for>. It also avoids polluting the program | |
793f5136 | 499 | with global variables and using symbolic references. |
5a964f20 | 500 | |
ac9dac7f | 501 | =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? |
d74e8afc | 502 | X<filehandle, local> X<filehandle, passing> X<filehandle, reference> |
68dc0745 | 503 | |
c90536be JH |
504 | As of perl5.6, open() autovivifies file and directory handles |
505 | as references if you pass it an uninitialized scalar variable. | |
506 | You can then pass these references just like any other scalar, | |
507 | and use them in the place of named handles. | |
68dc0745 | 508 | |
c90536be | 509 | open my $fh, $file_name; |
818c4caa | 510 | |
c90536be | 511 | open local $fh, $file_name; |
818c4caa | 512 | |
c90536be | 513 | print $fh "Hello World!\n"; |
818c4caa | 514 | |
c90536be | 515 | process_file( $fh ); |
68dc0745 | 516 | |
500071f4 RGS |
517 | If you like, you can store these filehandles in an array or a hash. |
518 | If you access them directly, they aren't simple scalars and you | |
ac9dac7f | 519 | need to give C<print> a little help by placing the filehandle |
500071f4 RGS |
520 | reference in braces. Perl can only figure it out on its own when |
521 | the filehandle reference is a simple scalar. | |
522 | ||
523 | my @fhs = ( $fh1, $fh2, $fh3 ); | |
ac9dac7f | 524 | |
500071f4 RGS |
525 | for( $i = 0; $i <= $#fhs; $i++ ) { |
526 | print {$fhs[$i]} "just another Perl answer, \n"; | |
527 | } | |
528 | ||
c90536be JH |
529 | Before perl5.6, you had to deal with various typeglob idioms |
530 | which you may see in older code. | |
68dc0745 | 531 | |
c90536be JH |
532 | open FILE, "> $filename"; |
533 | process_typeglob( *FILE ); | |
534 | process_reference( \*FILE ); | |
818c4caa | 535 | |
c90536be JH |
536 | sub process_typeglob { local *FH = shift; print FH "Typeglob!" } |
537 | sub process_reference { local $fh = shift; print $fh "Reference!" } | |
5a964f20 | 538 | |
c90536be JH |
539 | If you want to create many anonymous handles, you should |
540 | check out the Symbol or IO::Handle modules. | |
5a964f20 TC |
541 | |
542 | =head2 How can I use a filehandle indirectly? | |
d74e8afc | 543 | X<filehandle, indirect> |
5a964f20 | 544 | |
09c1cbc2 | 545 | An indirect filehandle is the use of something other than a symbol |
d12d61cf | 546 | in a place that a filehandle is expected. Here are ways |
a6dd486b | 547 | to get indirect filehandles: |
5a964f20 | 548 | |
500071f4 RGS |
549 | $fh = SOME_FH; # bareword is strict-subs hostile |
550 | $fh = "SOME_FH"; # strict-refs hostile; same package only | |
551 | $fh = *SOME_FH; # typeglob | |
552 | $fh = \*SOME_FH; # ref to typeglob (bless-able) | |
553 | $fh = *SOME_FH{IO}; # blessed IO::Handle from *SOME_FH typeglob | |
5a964f20 | 554 | |
c90536be | 555 | Or, you can use the C<new> method from one of the IO::* modules to |
09c1cbc2 | 556 | create an anonymous filehandle and store that in a scalar variable. |
5a964f20 | 557 | |
500071f4 | 558 | use IO::Handle; # 5.004 or higher |
d12d61cf | 559 | my $fh = IO::Handle->new(); |
5a964f20 | 560 | |
d12d61cf | 561 | Then use any of those as you would a normal filehandle. Anywhere that |
5a964f20 TC |
562 | Perl is expecting a filehandle, an indirect filehandle may be used |
563 | instead. An indirect filehandle is just a scalar variable that contains | |
d12d61cf | 564 | a filehandle. Functions like C<print>, C<open>, C<seek>, or |
c90536be | 565 | the C<< <FH> >> diamond operator will accept either a named filehandle |
5a964f20 TC |
566 | or a scalar variable containing one: |
567 | ||
500071f4 RGS |
568 | ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR); |
569 | print $ofh "Type it: "; | |
d12d61cf | 570 | my $got = <$ifh> |
500071f4 | 571 | print $efh "What was that: $got"; |
5a964f20 | 572 | |
368c9434 | 573 | If you're passing a filehandle to a function, you can write |
5a964f20 TC |
574 | the function in two ways: |
575 | ||
500071f4 RGS |
576 | sub accept_fh { |
577 | my $fh = shift; | |
578 | print $fh "Sending to indirect filehandle\n"; | |
579 | } | |
46fc3d4c | 580 | |
5a964f20 | 581 | Or it can localize a typeglob and use the filehandle directly: |
46fc3d4c | 582 | |
500071f4 RGS |
583 | sub accept_fh { |
584 | local *FH = shift; | |
585 | print FH "Sending to localized filehandle\n"; | |
586 | } | |
46fc3d4c | 587 | |
5a964f20 TC |
588 | Both styles work with either objects or typeglobs of real filehandles. |
589 | (They might also work with strings under some circumstances, but this | |
590 | is risky.) | |
591 | ||
500071f4 RGS |
592 | accept_fh(*STDOUT); |
593 | accept_fh($handle); | |
5a964f20 TC |
594 | |
595 | In the examples above, we assigned the filehandle to a scalar variable | |
d12d61cf | 596 | before using it. That is because only simple scalar variables, not |
a6dd486b | 597 | expressions or subscripts of hashes or arrays, can be used with |
d12d61cf | 598 | built-ins like C<print>, C<printf>, or the diamond operator. Using |
8305e449 | 599 | something other than a simple scalar variable as a filehandle is |
5a964f20 TC |
600 | illegal and won't even compile: |
601 | ||
d12d61cf | 602 | my @fd = (*STDIN, *STDOUT, *STDERR); |
500071f4 | 603 | print $fd[1] "Type it: "; # WRONG |
d12d61cf | 604 | my $got = <$fd[0]> # WRONG |
500071f4 | 605 | print $fd[2] "What was that: $got"; # WRONG |
5a964f20 TC |
606 | |
607 | With C<print> and C<printf>, you get around this by using a block and | |
608 | an expression where you would place the filehandle: | |
609 | ||
500071f4 RGS |
610 | print { $fd[1] } "funny stuff\n"; |
611 | printf { $fd[1] } "Pity the poor %x.\n", 3_735_928_559; | |
612 | # Pity the poor deadbeef. | |
5a964f20 TC |
613 | |
614 | That block is a proper block like any other, so you can put more | |
d12d61cf | 615 | complicated code there. This sends the message out to one of two places: |
5a964f20 | 616 | |
d12d61cf | 617 | my $ok = -x "/bin/cat"; |
500071f4 RGS |
618 | print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n"; |
619 | print { $fd[ 1+ ($ok || 0) ] } "cat stat $ok\n"; | |
5a964f20 TC |
620 | |
621 | This approach of treating C<print> and C<printf> like object methods | |
d12d61cf | 622 | calls doesn't work for the diamond operator. That's because it's a |
623 | real operator, not just a function with a comma-less argument. Assuming | |
5a964f20 | 624 | you've been storing typeglobs in your structure as we did above, you |
c90536be | 625 | can use the built-in function named C<readline> to read a record just |
d12d61cf | 626 | as C<< <> >> does. Given the initialization shown above for @fd, this |
627 | would work, but only because readline() requires a typeglob. It doesn't | |
5a964f20 TC |
628 | work with objects or strings, which might be a bug we haven't fixed yet. |
629 | ||
500071f4 | 630 | $got = readline($fd[0]); |
5a964f20 TC |
631 | |
632 | Let it be noted that the flakiness of indirect filehandles is not | |
633 | related to whether they're strings, typeglobs, objects, or anything else. | |
d12d61cf | 634 | It's the syntax of the fundamental operators. Playing the object |
5a964f20 | 635 | game doesn't help you at all here. |
46fc3d4c | 636 | |
68dc0745 | 637 | =head2 How can I set up a footer format to be used with write()? |
d74e8afc | 638 | X<footer> |
68dc0745 | 639 | |
54310121 | 640 | There's no builtin way to do this, but L<perlform> has a couple of |
68dc0745 | 641 | techniques to make it possible for the intrepid hacker. |
642 | ||
643 | =head2 How can I write() into a string? | |
d74e8afc | 644 | X<write, into a string> |
68dc0745 | 645 | |
3cd7ab71 | 646 | (contributed by brian d foy) |
647 | ||
84adb724 | 648 | If you want to C<write> into a string, you just have to <open> a |
3cd7ab71 | 649 | filehandle to a string, which Perl has been able to do since Perl 5.6: |
650 | ||
651 | open FH, '>', \my $string; | |
652 | write( FH ); | |
84adb724 | 653 | |
3cd7ab71 | 654 | Since you want to be a good programmer, you probably want to use a lexical |
655 | filehandle, even though formats are designed to work with bareword filehandles | |
84adb724 | 656 | since the default format names take the filehandle name. However, you can |
3cd7ab71 | 657 | control this with some Perl special per-filehandle variables: C<$^>, which |
658 | names the top-of-page format, and C<$~> which shows the line format. You have | |
659 | to change the default filehandle to set these variables: | |
660 | ||
661 | open my($fh), '>', \my $string; | |
84adb724 | 662 | |
3cd7ab71 | 663 | { # set per-filehandle variables |
664 | my $old_fh = select( $fh ); | |
665 | $~ = 'ANIMAL'; | |
666 | $^ = 'ANIMAL_TOP'; | |
667 | select( $old_fh ); | |
668 | } | |
669 | ||
670 | format ANIMAL_TOP = | |
671 | ID Type Name | |
672 | . | |
84adb724 | 673 | |
3cd7ab71 | 674 | format ANIMAL = |
675 | @## @<<< @<<<<<<<<<<<<<< | |
676 | $id, $type, $name | |
677 | . | |
678 | ||
679 | Although write can work with lexical or package variables, whatever variables | |
84adb724 | 680 | you use have to scope in the format. That most likely means you'll want to |
3cd7ab71 | 681 | localize some package variables: |
682 | ||
683 | { | |
684 | local( $id, $type, $name ) = qw( 12 cat Buster ); | |
685 | write( $fh ); | |
686 | } | |
84adb724 | 687 | |
3cd7ab71 | 688 | print $string; |
689 | ||
84adb724 | 690 | There are also some tricks that you can play with C<formline> and the |
3cd7ab71 | 691 | accumulator variable C<$^A>, but you lose a lot of the value of formats |
692 | since C<formline> won't handle paging and so on. You end up reimplementing | |
693 | formats when you use them. | |
68dc0745 | 694 | |
c195e131 | 695 | =head2 How can I open a filehandle to a string? |
109f0441 | 696 | X<string> X<open> X<IO::String> X<filehandle> |
c195e131 RGS |
697 | |
698 | (contributed by Peter J. Holzer, hjp-usenet2@hjp.at) | |
699 | ||
109f0441 S |
700 | Since Perl 5.8.0 a file handle referring to a string can be created by |
701 | calling open with a reference to that string instead of the filename. | |
702 | This file handle can then be used to read from or write to the string: | |
c195e131 RGS |
703 | |
704 | open(my $fh, '>', \$string) or die "Could not open string for writing"; | |
705 | print $fh "foo\n"; | |
706 | print $fh "bar\n"; # $string now contains "foo\nbar\n" | |
707 | ||
708 | open(my $fh, '<', \$string) or die "Could not open string for reading"; | |
709 | my $x = <$fh>; # $x now contains "foo\n" | |
710 | ||
711 | With older versions of Perl, the C<IO::String> module provides similar | |
712 | functionality. | |
487af187 | 713 | |
68dc0745 | 714 | =head2 How can I output my numbers with commas added? |
d74e8afc | 715 | X<number, commify> |
68dc0745 | 716 | |
b68463f7 RGS |
717 | (contributed by brian d foy and Benjamin Goldberg) |
718 | ||
719 | You can use L<Number::Format> to separate places in a number. | |
720 | It handles locale information for those of you who want to insert | |
721 | full stops instead (or anything else that they want to use, | |
722 | really). | |
723 | ||
49d635f9 RGS |
724 | This subroutine will add commas to your number: |
725 | ||
726 | sub commify { | |
500071f4 RGS |
727 | local $_ = shift; |
728 | 1 while s/^([-+]?\d+)(\d{3})/$1,$2/; | |
729 | return $_; | |
730 | } | |
49d635f9 RGS |
731 | |
732 | This regex from Benjamin Goldberg will add commas to numbers: | |
68dc0745 | 733 | |
500071f4 | 734 | s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g; |
68dc0745 | 735 | |
49d635f9 | 736 | It is easier to see with comments: |
68dc0745 | 737 | |
500071f4 RGS |
738 | s/( |
739 | ^[-+]? # beginning of number. | |
740 | \d+? # first digits before first comma | |
741 | (?= # followed by, (but not included in the match) : | |
742 | (?>(?:\d{3})+) # some positive multiple of three digits. | |
743 | (?!\d) # an *exact* multiple, not x * 3 + 1 or whatever. | |
744 | ) | |
745 | | # or: | |
746 | \G\d{3} # after the last group, get three digits | |
747 | (?=\d) # but they have to have more digits after them. | |
748 | )/$1,/xg; | |
46fc3d4c | 749 | |
68dc0745 | 750 | =head2 How can I translate tildes (~) in a filename? |
d74e8afc | 751 | X<tilde> X<tilde expansion> |
68dc0745 | 752 | |
109f0441 S |
753 | Use the E<lt>E<gt> (C<glob()>) operator, documented in L<perlfunc>. |
754 | Versions of Perl older than 5.6 require that you have a shell | |
d12d61cf | 755 | installed that groks tildes. Later versions of Perl have this feature |
109f0441 S |
756 | built in. The C<File::KGlob> module (available from CPAN) gives more |
757 | portable glob functionality. | |
68dc0745 | 758 | |
759 | Within Perl, you may use this directly: | |
760 | ||
761 | $filename =~ s{ | |
762 | ^ ~ # find a leading tilde | |
763 | ( # save this in $1 | |
764 | [^/] # a non-slash character | |
765 | * # repeated 0 or more times (0 means me) | |
766 | ) | |
767 | }{ | |
768 | $1 | |
769 | ? (getpwnam($1))[7] | |
770 | : ( $ENV{HOME} || $ENV{LOGDIR} ) | |
771 | }ex; | |
772 | ||
5a964f20 | 773 | =head2 How come when I open a file read-write it wipes it out? |
d74e8afc | 774 | X<clobber> X<read-write> X<clobbering> X<truncate> X<truncating> |
68dc0745 | 775 | |
eadf64ed | 776 | Because you're using something like this, which truncates the file |
68dc0745 | 777 | I<then> gives you read-write access: |
778 | ||
d12d61cf | 779 | open my $fh, '+>', '/path/name'; # WRONG (almost always) |
68dc0745 | 780 | |
d12d61cf | 781 | Whoops. You should instead use this, which will fail if the file |
eadf64ed | 782 | doesn't exist: |
d92eb7b0 | 783 | |
d12d61cf | 784 | open my $fh, '+<', '/path/name'; # open for update |
d92eb7b0 | 785 | |
d12d61cf | 786 | Using ">" always clobbers or creates. Using "<" never does |
787 | either. The "+" doesn't change this. | |
68dc0745 | 788 | |
eadf64ed | 789 | Here are examples of many kinds of file opens. Those using C<sysopen> |
790 | all assume that you've pulled in the constants from C<Fcntl>: | |
68dc0745 | 791 | |
500071f4 | 792 | use Fcntl; |
68dc0745 | 793 | |
5a964f20 | 794 | To open file for reading: |
68dc0745 | 795 | |
eadf64ed | 796 | open my $fh, '<', $path or die $!; |
797 | sysopen my $fh, $path, O_RDONLY or die $!; | |
5a964f20 TC |
798 | |
799 | To open file for writing, create new file if needed or else truncate old file: | |
800 | ||
eadf64ed | 801 | open my $fh, '>', $path or die $!; |
802 | sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT or die $!; | |
803 | sysopen my $fh, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666 or die $!; | |
5a964f20 TC |
804 | |
805 | To open file for writing, create new file, file must not exist: | |
806 | ||
eadf64ed | 807 | sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT or die $!; |
808 | sysopen my $fh, $path, O_WRONLY|O_EXCL|O_CREAT, 0666 or die $!; | |
5a964f20 TC |
809 | |
810 | To open file for appending, create if necessary: | |
811 | ||
eadf64ed | 812 | open my $fh, '>>' $path or die $!; |
813 | sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT or die $!; | |
814 | sysopen my $fh, $path, O_WRONLY|O_APPEND|O_CREAT, 0666 or die $!; | |
5a964f20 TC |
815 | |
816 | To open file for appending, file must exist: | |
817 | ||
eadf64ed | 818 | sysopen my $fh, $path, O_WRONLY|O_APPEND or die $!; |
5a964f20 TC |
819 | |
820 | To open file for update, file must exist: | |
821 | ||
eadf64ed | 822 | open my $fh, '+<', $path or die $!; |
823 | sysopen my $fh, $path, O_RDWR or die $!; | |
5a964f20 TC |
824 | |
825 | To open file for update, create file if necessary: | |
826 | ||
eadf64ed | 827 | sysopen my $fh, $path, O_RDWR|O_CREAT or die $!; |
828 | sysopen my $fh, $path, O_RDWR|O_CREAT, 0666 or die $!; | |
5a964f20 TC |
829 | |
830 | To open file for update, file must not exist: | |
831 | ||
eadf64ed | 832 | sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT or die $!; |
833 | sysopen my $fh, $path, O_RDWR|O_EXCL|O_CREAT, 0666 or die $!; | |
5a964f20 TC |
834 | |
835 | To open a file without blocking, creating if necessary: | |
836 | ||
d12d61cf | 837 | sysopen my $fh, '/foo/somefile', O_WRONLY|O_NDELAY|O_CREAT |
2359510d | 838 | or die "can't open /foo/somefile: $!": |
5a964f20 TC |
839 | |
840 | Be warned that neither creation nor deletion of files is guaranteed to | |
d12d61cf | 841 | be an atomic operation over NFS. That is, two processes might both |
842 | successfully create or unlink the same file! Therefore O_EXCL | |
a6dd486b | 843 | isn't as exclusive as you might wish. |
68dc0745 | 844 | |
09c1cbc2 | 845 | See also L<perlopentut>. |
65acb1b1 | 846 | |
04d666b1 | 847 | =head2 Why do I sometimes get an "Argument list too long" when I use E<lt>*E<gt>? |
d74e8afc | 848 | X<argument list too long> |
68dc0745 | 849 | |
c47ff5f1 | 850 | The C<< <> >> operator performs a globbing operation (see above). |
3a4b19e4 GS |
851 | In Perl versions earlier than v5.6.0, the internal glob() operator forks |
852 | csh(1) to do the actual glob expansion, but | |
68dc0745 | 853 | csh can't handle more than 127 items and so gives the error message |
d12d61cf | 854 | C<Argument list too long>. People who installed tcsh as csh won't |
68dc0745 | 855 | have this problem, but their users may be surprised by it. |
856 | ||
3a4b19e4 | 857 | To get around this, either upgrade to Perl v5.6.0 or later, do the glob |
d6260402 | 858 | yourself with readdir() and patterns, or use a module like File::KGlob, |
3a4b19e4 | 859 | one that doesn't use the shell to do globbing. |
68dc0745 | 860 | |
861 | =head2 Is there a leak/bug in glob()? | |
d74e8afc | 862 | X<glob> |
68dc0745 | 863 | |
589a5df2 | 864 | (contributed by brian d foy) |
f12f5f55 | 865 | |
866 | Starting with Perl 5.6.0, C<glob> is implemented internally rather | |
d12d61cf | 867 | than relying on an external resource. As such, memory issues with |
f12f5f55 | 868 | C<glob> aren't a problem in modern perls. |
68dc0745 | 869 | |
c47ff5f1 | 870 | =head2 How can I open a file with a leading ">" or trailing blanks? |
d74e8afc | 871 | X<filename, special characters> |
68dc0745 | 872 | |
b68463f7 | 873 | (contributed by Brian McCauley) |
68dc0745 | 874 | |
09c1cbc2 | 875 | The special two-argument form of Perl's open() function ignores |
b68463f7 RGS |
876 | trailing blanks in filenames and infers the mode from certain leading |
877 | characters (or a trailing "|"). In older versions of Perl this was the | |
878 | only version of open() and so it is prevalent in old code and books. | |
65acb1b1 | 879 | |
09c1cbc2 FC |
880 | Unless you have a particular reason to use the two-argument form you |
881 | should use the three-argument form of open() which does not treat any | |
c195e131 | 882 | characters in the filename as special. |
58103a2e | 883 | |
d12d61cf | 884 | open my $fh, "<", " file "; # filename is " file " |
885 | open my $fh, ">", ">file"; # filename is ">file" | |
65acb1b1 | 886 | |
68dc0745 | 887 | =head2 How can I reliably rename a file? |
f12f5f55 | 888 | X<rename> X<mv> X<move> X<file, rename> |
68dc0745 | 889 | |
49d635f9 RGS |
890 | If your operating system supports a proper mv(1) utility or its |
891 | functional equivalent, this works: | |
68dc0745 | 892 | |
500071f4 | 893 | rename($old, $new) or system("mv", $old, $new); |
68dc0745 | 894 | |
f12f5f55 | 895 | It may be more portable to use the C<File::Copy> module instead. |
d2321c93 | 896 | You just copy to the new file to the new name (checking return |
d12d61cf | 897 | values), then delete the old one. This isn't really the same |
f12f5f55 | 898 | semantically as a C<rename()>, which preserves meta-information like |
68dc0745 | 899 | permissions, timestamps, inode info, etc. |
900 | ||
901 | =head2 How can I lock a file? | |
d74e8afc | 902 | X<lock> X<file, lock> X<flock> |
68dc0745 | 903 | |
54310121 | 904 | Perl's builtin flock() function (see L<perlfunc> for details) will call |
68dc0745 | 905 | flock(2) if that exists, fcntl(2) if it doesn't (on perl version 5.004 and |
906 | later), and lockf(3) if neither of the two previous system calls exists. | |
907 | On some systems, it may even use a different form of native locking. | |
908 | Here are some gotchas with Perl's flock(): | |
909 | ||
910 | =over 4 | |
911 | ||
912 | =item 1 | |
913 | ||
914 | Produces a fatal error if none of the three system calls (or their | |
915 | close equivalent) exists. | |
916 | ||
917 | =item 2 | |
918 | ||
919 | lockf(3) does not provide shared locking, and requires that the | |
920 | filehandle be open for writing (or appending, or read/writing). | |
921 | ||
922 | =item 3 | |
923 | ||
d92eb7b0 GS |
924 | Some versions of flock() can't lock files over a network (e.g. on NFS file |
925 | systems), so you'd need to force the use of fcntl(2) when you build Perl. | |
d12d61cf | 926 | But even this is dubious at best. See the flock entry of L<perlfunc> |
d92eb7b0 GS |
927 | and the F<INSTALL> file in the source distribution for information on |
928 | building Perl to do this. | |
929 | ||
930 | Two potentially non-obvious but traditional flock semantics are that | |
a6dd486b | 931 | it waits indefinitely until the lock is granted, and that its locks are |
d12d61cf | 932 | I<merely advisory>. Such discretionary locks are more flexible, but |
933 | offer fewer guarantees. This means that files locked with flock() may | |
934 | be modified by programs that do not also use flock(). Cars that stop | |
d92eb7b0 | 935 | for red lights get on well with each other, but not with cars that don't |
d12d61cf | 936 | stop for red lights. See the perlport manpage, your port's specific |
937 | documentation, or your system-specific local manpages for details. It's | |
d92eb7b0 | 938 | best to assume traditional behavior if you're writing portable programs. |
a6dd486b | 939 | (If you're not, you should as always feel perfectly free to write |
d92eb7b0 GS |
940 | for your own system's idiosyncrasies (sometimes called "features"). |
941 | Slavish adherence to portability concerns shouldn't get in the way of | |
942 | your getting your job done.) | |
68dc0745 | 943 | |
197aec24 | 944 | For more information on file locking, see also |
13a2d996 | 945 | L<perlopentut/"File Locking"> if you have it (new for 5.6). |
65acb1b1 | 946 | |
68dc0745 | 947 | =back |
948 | ||
04d666b1 | 949 | =head2 Why can't I just open(FH, "E<gt>file.lock")? |
d74e8afc | 950 | X<lock, lockfile race condition> |
68dc0745 | 951 | |
952 | A common bit of code B<NOT TO USE> is this: | |
953 | ||
d12d61cf | 954 | sleep(3) while -e 'file.lock'; # PLEASE DO NOT USE |
955 | open my $lock, '>', 'file.lock'; # THIS BROKEN CODE | |
68dc0745 | 956 | |
957 | This is a classic race condition: you take two steps to do something | |
d12d61cf | 958 | which must be done in one. That's why computer hardware provides an |
959 | atomic test-and-set instruction. In theory, this "ought" to work: | |
68dc0745 | 960 | |
d12d61cf | 961 | sysopen my $fh, "file.lock", O_WRONLY|O_EXCL|O_CREAT |
9b55d3ab | 962 | or die "can't open file.lock: $!"; |
68dc0745 | 963 | |
964 | except that lamentably, file creation (and deletion) is not atomic | |
965 | over NFS, so this won't work (at least, not every time) over the net. | |
65acb1b1 | 966 | Various schemes involving link() have been suggested, but |
c195e131 | 967 | these tend to involve busy-wait, which is also less than desirable. |
68dc0745 | 968 | |
d12d61cf | 969 | =head2 I still don't get locking. I just want to increment the number in the file. How can I do this? |
d74e8afc | 970 | X<counter> X<file, counter> |
68dc0745 | 971 | |
46fc3d4c | 972 | Didn't anyone ever tell you web-page hit counters were useless? |
5a964f20 | 973 | They don't count number of hits, they're a waste of time, and they serve |
d12d61cf | 974 | only to stroke the writer's vanity. It's better to pick a random number; |
a6dd486b | 975 | they're more realistic. |
68dc0745 | 976 | |
5a964f20 | 977 | Anyway, this is what you can do if you can't help yourself. |
68dc0745 | 978 | |
500071f4 | 979 | use Fcntl qw(:DEFAULT :flock); |
d12d61cf | 980 | sysopen my $fh, "numfile", O_RDWR|O_CREAT or die "can't open numfile: $!"; |
981 | flock $fh, LOCK_EX or die "can't flock numfile: $!"; | |
982 | my $num = <$fh> || 0; | |
983 | seek $fh, 0, 0 or die "can't rewind numfile: $!"; | |
984 | truncate $fh, 0 or die "can't truncate numfile: $!"; | |
985 | (print $fh $num+1, "\n") or die "can't write numfile: $!"; | |
986 | close $fh or die "can't close numfile: $!"; | |
68dc0745 | 987 | |
46fc3d4c | 988 | Here's a much better web-page hit counter: |
68dc0745 | 989 | |
500071f4 | 990 | $hits = int( (time() - 850_000_000) / rand(1_000) ); |
68dc0745 | 991 | |
d12d61cf | 992 | If the count doesn't impress your friends, then the code might. :-) |
68dc0745 | 993 | |
d12d61cf | 994 | =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? |
d74e8afc | 995 | X<append> X<file, append> |
05caf3a7 | 996 | |
109f0441 S |
997 | If you are on a system that correctly implements C<flock> and you use |
998 | the example appending code from "perldoc -f flock" everything will be | |
999 | OK even if the OS you are on doesn't implement append mode correctly | |
09c1cbc2 | 1000 | (if such a system exists). So if you are happy to restrict yourself to |
109f0441 S |
1001 | OSs that implement C<flock> (and that's not really much of a |
1002 | restriction) then that is what you should do. | |
05caf3a7 GJ |
1003 | |
1004 | If you know you are only going to use a system that does correctly | |
109f0441 S |
1005 | implement appending (i.e. not Win32) then you can omit the C<seek> |
1006 | from the code in the previous answer. | |
1007 | ||
1008 | If you know you are only writing code to run on an OS and filesystem | |
1009 | that does implement append mode correctly (a local filesystem on a | |
1010 | modern Unix for example), and you keep the file in block-buffered mode | |
1011 | and you write less than one buffer-full of output between each manual | |
1012 | flushing of the buffer then each bufferload is almost guaranteed to be | |
1013 | written to the end of the file in one chunk without getting | |
1014 | intermingled with anyone else's output. You can also use the | |
1015 | C<syswrite> function which is simply a wrapper around your system's | |
1016 | C<write(2)> system call. | |
05caf3a7 GJ |
1017 | |
1018 | There is still a small theoretical chance that a signal will interrupt | |
09c1cbc2 | 1019 | the system-level C<write()> operation before completion. There is also |
109f0441 S |
1020 | a possibility that some STDIO implementations may call multiple system |
1021 | level C<write()>s even if the buffer was empty to start. There may be | |
1022 | some systems where this probability is reduced to zero, and this is | |
1023 | not a concern when using C<:perlio> instead of your system's STDIO. | |
05caf3a7 | 1024 | |
68dc0745 | 1025 | =head2 How do I randomly update a binary file? |
d74e8afc | 1026 | X<file, binary patch> |
68dc0745 | 1027 | |
1028 | If you're just trying to patch a binary, in many cases something as | |
1029 | simple as this works: | |
1030 | ||
500071f4 | 1031 | perl -i -pe 's{window manager}{window mangler}g' /usr/bin/emacs |
68dc0745 | 1032 | |
1033 | However, if you have fixed sized records, then you might do something more | |
1034 | like this: | |
1035 | ||
500071f4 RGS |
1036 | $RECSIZE = 220; # size of record, in bytes |
1037 | $recno = 37; # which record to update | |
d12d61cf | 1038 | open my $fh, '+<', 'somewhere' or die "can't update somewhere: $!"; |
1039 | seek $fh, $recno * $RECSIZE, 0; | |
1040 | read $fh, $record, $RECSIZE == $RECSIZE or die "can't read record $recno: $!"; | |
500071f4 | 1041 | # munge the record |
d12d61cf | 1042 | seek $fh, -$RECSIZE, 1; |
1043 | print $fh $record; | |
1044 | close $fh; | |
68dc0745 | 1045 | |
1046 | Locking and error checking are left as an exercise for the reader. | |
a6dd486b | 1047 | Don't forget them or you'll be quite sorry. |
68dc0745 | 1048 | |
68dc0745 | 1049 | =head2 How do I get a file's timestamp in perl? |
d74e8afc | 1050 | X<timestamp> X<file, timestamp> |
68dc0745 | 1051 | |
589a5df2 | 1052 | If you want to retrieve the time at which the file was last read, |
1053 | written, or had its meta-data (owner, etc) changed, you use the B<-A>, | |
1054 | B<-M>, or B<-C> file test operations as documented in L<perlfunc>. | |
1055 | These retrieve the age of the file (measured against the start-time of | |
1056 | your program) in days as a floating point number. Some platforms may | |
d12d61cf | 1057 | not have all of these times. See L<perlport> for details. To retrieve |
589a5df2 | 1058 | the "raw" time in seconds since the epoch, you would call the stat |
1059 | function, then use C<localtime()>, C<gmtime()>, or | |
1060 | C<POSIX::strftime()> to convert this into human-readable form. | |
68dc0745 | 1061 | |
1062 | Here's an example: | |
1063 | ||
d12d61cf | 1064 | my $write_secs = (stat($file))[9]; |
500071f4 | 1065 | printf "file %s updated at %s\n", $file, |
c8db1d39 | 1066 | scalar localtime($write_secs); |
68dc0745 | 1067 | |
1068 | If you prefer something more legible, use the File::stat module | |
1069 | (part of the standard distribution in version 5.004 and later): | |
1070 | ||
500071f4 RGS |
1071 | # error checking left as an exercise for reader. |
1072 | use File::stat; | |
1073 | use Time::localtime; | |
d12d61cf | 1074 | my $date_string = ctime(stat($file)->mtime); |
500071f4 | 1075 | print "file $file updated at $date_string\n"; |
68dc0745 | 1076 | |
65acb1b1 | 1077 | The POSIX::strftime() approach has the benefit of being, |
d12d61cf | 1078 | in theory, independent of the current locale. See L<perllocale> |
65acb1b1 | 1079 | for details. |
68dc0745 | 1080 | |
1081 | =head2 How do I set a file's timestamp in perl? | |
d74e8afc | 1082 | X<timestamp> X<file, timestamp> |
68dc0745 | 1083 | |
1084 | You use the utime() function documented in L<perlfunc/utime>. | |
1085 | By way of example, here's a little program that copies the | |
1086 | read and write times from its first argument to all the rest | |
1087 | of them. | |
1088 | ||
500071f4 RGS |
1089 | if (@ARGV < 2) { |
1090 | die "usage: cptimes timestamp_file other_files ...\n"; | |
1091 | } | |
d12d61cf | 1092 | my $timestamp = shift; |
1093 | my($atime, $mtime) = (stat($timestamp))[8,9]; | |
500071f4 | 1094 | utime $atime, $mtime, @ARGV; |
68dc0745 | 1095 | |
65acb1b1 | 1096 | Error checking is, as usual, left as an exercise for the reader. |
68dc0745 | 1097 | |
19a1cd16 SP |
1098 | The perldoc for utime also has an example that has the same |
1099 | effect as touch(1) on files that I<already exist>. | |
1100 | ||
1101 | Certain file systems have a limited ability to store the times | |
d12d61cf | 1102 | on a file at the expected level of precision. For example, the |
19a1cd16 | 1103 | FAT and HPFS filesystem are unable to create dates on files with |
d12d61cf | 1104 | a finer granularity than two seconds. This is a limitation of |
19a1cd16 | 1105 | the filesystems, not of utime(). |
68dc0745 | 1106 | |
1107 | =head2 How do I print to more than one file at once? | |
d74e8afc | 1108 | X<print, to multiple files> |
68dc0745 | 1109 | |
49d635f9 RGS |
1110 | To connect one filehandle to several output filehandles, |
1111 | you can use the IO::Tee or Tie::FileHandle::Multiplex modules. | |
68dc0745 | 1112 | |
49d635f9 RGS |
1113 | If you only have to do this once, you can print individually |
1114 | to each filehandle. | |
68dc0745 | 1115 | |
d12d61cf | 1116 | for my $fh (FH1, FH2, FH3) { print $fh "whatever\n" } |
5a964f20 | 1117 | |
49d635f9 | 1118 | =head2 How can I read in an entire file all at once? |
d74e8afc | 1119 | X<slurp> X<file, slurping> |
68dc0745 | 1120 | |
d92eb7b0 GS |
1121 | The customary Perl approach for processing all the lines in a file is to |
1122 | do so one line at a time: | |
1123 | ||
d12d61cf | 1124 | open my $input, '<', $file or die "can't open $file: $!"; |
1125 | while (<$input>) { | |
500071f4 RGS |
1126 | chomp; |
1127 | # do something with $_ | |
1128 | } | |
d12d61cf | 1129 | close $input or die "can't close $file: $!"; |
d92eb7b0 GS |
1130 | |
1131 | This is tremendously more efficient than reading the entire file into | |
1132 | memory as an array of lines and then processing it one element at a time, | |
d12d61cf | 1133 | which is often--if not almost always--the wrong approach. Whenever |
d92eb7b0 GS |
1134 | you see someone do this: |
1135 | ||
d12d61cf | 1136 | my @lines = <INPUT>; |
d92eb7b0 | 1137 | |
d12d61cf | 1138 | You should think long and hard about why you need everything loaded at |
5c121ae8 FC |
1139 | once. It's just not a scalable solution. |
1140 | ||
1141 | If you "mmap" the file with the File::Map module from | |
1142 | CPAN, you can virtually load the entire file into a | |
1143 | string without actually storing it in memory: | |
1144 | ||
1145 | use File::Map qw(map_file); | |
1146 | ||
1147 | map_file my $string, $filename; | |
1148 | ||
1149 | Once mapped, you can treat C<$string> as you would any other string. | |
1150 | Since you don't necessarily have to load the data, mmap-ing can be | |
1151 | very fast and may not increase your memory footprint. | |
1152 | ||
1153 | You might also find it more | |
7a98bd75 | 1154 | fun to use the standard C<Tie::File> module, or the C<DB_File> module's |
1155 | C<$DB_RECNO> bindings, which allow you to tie an array to a file so that | |
09c1cbc2 | 1156 | accessing an element of the array actually accesses the corresponding |
30852c57 | 1157 | line in the file. |
d92eb7b0 | 1158 | |
5c121ae8 FC |
1159 | If you want to load the entire file, you can use the C<File::Slurp> |
1160 | module to do it in one one simple and efficient step: | |
1161 | ||
1162 | use File::Slurp; | |
1163 | ||
1164 | my $all_of_it = read_file($filename); # entire file in scalar | |
1165 | my @all_lines = read_file($filename); # one line per element | |
1166 | ||
1167 | Or you can read the entire file contents into a scalar like this: | |
d92eb7b0 | 1168 | |
7a98bd75 | 1169 | my $var; |
500071f4 | 1170 | { |
d12d61cf | 1171 | local $/; |
1172 | open my $fh, '<', $file or die "can't open $file: $!"; | |
1173 | $var = <$fh>; | |
500071f4 | 1174 | } |
d92eb7b0 | 1175 | |
197aec24 | 1176 | That temporarily undefs your record separator, and will automatically |
d12d61cf | 1177 | close the file at block exit. If the file is already open, just use this: |
d92eb7b0 | 1178 | |
7a98bd75 | 1179 | my $var = do { local $/; <$fh> }; |
d92eb7b0 | 1180 | |
5c121ae8 | 1181 | You can also use a localized C<@ARGV> to eliminate the C<open>: |
7a98bd75 | 1182 | |
1183 | my $var = do { local( @ARGV, $/ ) = $file; <> }; | |
1184 | ||
1185 | For ordinary files you can also use the C<read> function. | |
f05bbc40 | 1186 | |
d12d61cf | 1187 | read( $fh, $var, -s $fh ); |
f05bbc40 | 1188 | |
5c121ae8 | 1189 | That third argument tests the byte size of the data on the C<$fh> filehandle |
7a98bd75 | 1190 | and reads that many bytes into the buffer C<$var>. |
f05bbc40 | 1191 | |
68dc0745 | 1192 | =head2 How can I read in a file by paragraphs? |
d74e8afc | 1193 | X<file, reading by paragraphs> |
68dc0745 | 1194 | |
d12d61cf | 1195 | Use the C<$/> variable (see L<perlvar> for details). You can either |
68dc0745 | 1196 | set it to C<""> to eliminate empty paragraphs (C<"abc\n\n\n\ndef">, |
1197 | for instance, gets treated as two paragraphs and not three), or | |
1198 | C<"\n\n"> to accept empty paragraphs. | |
1199 | ||
d12d61cf | 1200 | Note that a blank line must have no blanks in it. Thus |
c4db748a | 1201 | S<C<"fred\n \nstuff\n\n">> is one paragraph, but C<"fred\n\nstuff\n\n"> is two. |
65acb1b1 | 1202 | |
68dc0745 | 1203 | =head2 How can I read a single character from a file? From the keyboard? |
d74e8afc | 1204 | X<getc> X<file, reading one character at a time> |
68dc0745 | 1205 | |
1206 | You can use the builtin C<getc()> function for most filehandles, but | |
d12d61cf | 1207 | it won't (easily) work on a terminal device. For STDIN, either use |
a6dd486b | 1208 | the Term::ReadKey module from CPAN or use the sample code in |
68dc0745 | 1209 | L<perlfunc/getc>. |
1210 | ||
65acb1b1 TC |
1211 | If your system supports the portable operating system programming |
1212 | interface (POSIX), you can use the following code, which you'll note | |
1213 | turns off echo processing as well. | |
68dc0745 | 1214 | |
500071f4 RGS |
1215 | #!/usr/bin/perl -w |
1216 | use strict; | |
1217 | $| = 1; | |
1218 | for (1..4) { | |
500071f4 | 1219 | print "gimme: "; |
d12d61cf | 1220 | my $got = getone(); |
500071f4 RGS |
1221 | print "--> $got\n"; |
1222 | } | |
68dc0745 | 1223 | exit; |
1224 | ||
500071f4 | 1225 | BEGIN { |
68dc0745 | 1226 | use POSIX qw(:termios_h); |
1227 | ||
1228 | my ($term, $oterm, $echo, $noecho, $fd_stdin); | |
1229 | ||
d12d61cf | 1230 | my $fd_stdin = fileno(STDIN); |
68dc0745 | 1231 | |
1232 | $term = POSIX::Termios->new(); | |
1233 | $term->getattr($fd_stdin); | |
1234 | $oterm = $term->getlflag(); | |
1235 | ||
1236 | $echo = ECHO | ECHOK | ICANON; | |
1237 | $noecho = $oterm & ~$echo; | |
1238 | ||
1239 | sub cbreak { | |
500071f4 RGS |
1240 | $term->setlflag($noecho); |
1241 | $term->setcc(VTIME, 1); | |
1242 | $term->setattr($fd_stdin, TCSANOW); | |
1243 | } | |
ac9dac7f | 1244 | |
68dc0745 | 1245 | sub cooked { |
500071f4 RGS |
1246 | $term->setlflag($oterm); |
1247 | $term->setcc(VTIME, 0); | |
1248 | $term->setattr($fd_stdin, TCSANOW); | |
1249 | } | |
68dc0745 | 1250 | |
1251 | sub getone { | |
500071f4 RGS |
1252 | my $key = ''; |
1253 | cbreak(); | |
1254 | sysread(STDIN, $key, 1); | |
1255 | cooked(); | |
1256 | return $key; | |
1257 | } | |
68dc0745 | 1258 | |
500071f4 | 1259 | } |
68dc0745 | 1260 | |
500071f4 | 1261 | END { cooked() } |
68dc0745 | 1262 | |
d12d61cf | 1263 | The Term::ReadKey module from CPAN may be easier to use. Recent versions |
65acb1b1 | 1264 | include also support for non-portable systems as well. |
68dc0745 | 1265 | |
500071f4 | 1266 | use Term::ReadKey; |
d12d61cf | 1267 | open my $tty, '<', '/dev/tty'; |
500071f4 RGS |
1268 | print "Gimme a char: "; |
1269 | ReadMode "raw"; | |
d12d61cf | 1270 | my $key = ReadKey 0, $tty; |
500071f4 RGS |
1271 | ReadMode "normal"; |
1272 | printf "\nYou said %s, char number %03d\n", | |
1273 | $key, ord $key; | |
68dc0745 | 1274 | |
65acb1b1 | 1275 | =head2 How can I tell whether there's a character waiting on a filehandle? |
68dc0745 | 1276 | |
5a964f20 | 1277 | The very first thing you should do is look into getting the Term::ReadKey |
d12d61cf | 1278 | extension from CPAN. As we mentioned earlier, it now even has limited |
65acb1b1 | 1279 | support for non-portable (read: not open systems, closed, proprietary, |
589a5df2 | 1280 | not POSIX, not Unix, etc.) systems. |
5a964f20 TC |
1281 | |
1282 | You should also check out the Frequently Asked Questions list in | |
68dc0745 | 1283 | comp.unix.* for things like this: the answer is essentially the same. |
09c1cbc2 | 1284 | It's very system-dependent. Here's one solution that works on BSD |
68dc0745 | 1285 | systems: |
1286 | ||
500071f4 RGS |
1287 | sub key_ready { |
1288 | my($rin, $nfd); | |
1289 | vec($rin, fileno(STDIN), 1) = 1; | |
1290 | return $nfd = select($rin,undef,undef,0); | |
1291 | } | |
68dc0745 | 1292 | |
65acb1b1 | 1293 | If you want to find out how many characters are waiting, there's |
d12d61cf | 1294 | also the FIONREAD ioctl call to be looked at. The I<h2ph> tool that |
65acb1b1 | 1295 | comes with Perl tries to convert C include files to Perl code, which |
d12d61cf | 1296 | can be C<require>d. FIONREAD ends up defined as a function in the |
65acb1b1 | 1297 | I<sys/ioctl.ph> file: |
68dc0745 | 1298 | |
500071f4 | 1299 | require 'sys/ioctl.ph'; |
68dc0745 | 1300 | |
500071f4 RGS |
1301 | $size = pack("L", 0); |
1302 | ioctl(FH, FIONREAD(), $size) or die "Couldn't call ioctl: $!\n"; | |
1303 | $size = unpack("L", $size); | |
68dc0745 | 1304 | |
5a964f20 TC |
1305 | If I<h2ph> wasn't installed or doesn't work for you, you can |
1306 | I<grep> the include files by hand: | |
68dc0745 | 1307 | |
500071f4 RGS |
1308 | % grep FIONREAD /usr/include/*/* |
1309 | /usr/include/asm/ioctls.h:#define FIONREAD 0x541B | |
68dc0745 | 1310 | |
5a964f20 | 1311 | Or write a small C program using the editor of champions: |
68dc0745 | 1312 | |
500071f4 RGS |
1313 | % cat > fionread.c |
1314 | #include <sys/ioctl.h> | |
1315 | main() { | |
1316 | printf("%#08x\n", FIONREAD); | |
1317 | } | |
1318 | ^D | |
1319 | % cc -o fionread fionread.c | |
1320 | % ./fionread | |
1321 | 0x4004667f | |
5a964f20 | 1322 | |
09c1cbc2 | 1323 | And then hard-code it, leaving porting as an exercise to your successor. |
5a964f20 | 1324 | |
500071f4 | 1325 | $FIONREAD = 0x4004667f; # XXX: opsys dependent |
5a964f20 | 1326 | |
500071f4 RGS |
1327 | $size = pack("L", 0); |
1328 | ioctl(FH, $FIONREAD, $size) or die "Couldn't call ioctl: $!\n"; | |
1329 | $size = unpack("L", $size); | |
5a964f20 | 1330 | |
a6dd486b | 1331 | FIONREAD requires a filehandle connected to a stream, meaning that sockets, |
5a964f20 | 1332 | pipes, and tty devices work, but I<not> files. |
68dc0745 | 1333 | |
1334 | =head2 How do I do a C<tail -f> in perl? | |
ac9dac7f | 1335 | X<tail> X<IO::Handle> X<File::Tail> X<clearerr> |
68dc0745 | 1336 | |
1337 | First try | |
1338 | ||
500071f4 | 1339 | seek(GWFILE, 0, 1); |
68dc0745 | 1340 | |
1341 | The statement C<seek(GWFILE, 0, 1)> doesn't change the current position, | |
1342 | but it does clear the end-of-file condition on the handle, so that the | |
ac9dac7f | 1343 | next C<< <GWFILE> >> makes Perl try again to read something. |
68dc0745 | 1344 | |
1345 | If that doesn't work (it relies on features of your stdio implementation), | |
1346 | then you need something more like this: | |
1347 | ||
1348 | for (;;) { | |
1349 | for ($curpos = tell(GWFILE); <GWFILE>; $curpos = tell(GWFILE)) { | |
1350 | # search for some stuff and put it into files | |
1351 | } | |
1352 | # sleep for a while | |
1353 | seek(GWFILE, $curpos, 0); # seek to where we had been | |
1354 | } | |
1355 | ||
ac9dac7f RGS |
1356 | If this still doesn't work, look into the C<clearerr> method |
1357 | from C<IO::Handle>, which resets the error and end-of-file states | |
1358 | on the handle. | |
68dc0745 | 1359 | |
ac9dac7f | 1360 | There's also a C<File::Tail> module from CPAN. |
65acb1b1 | 1361 | |
68dc0745 | 1362 | =head2 How do I dup() a filehandle in Perl? |
d74e8afc | 1363 | X<dup> |
68dc0745 | 1364 | |
1365 | If you check L<perlfunc/open>, you'll see that several of the ways | |
d12d61cf | 1366 | to call open() should do the trick. For example: |
68dc0745 | 1367 | |
d12d61cf | 1368 | open my $log, '>>', '/foo/logfile'; |
1369 | open STDERR, '>&LOG'; | |
68dc0745 | 1370 | |
1371 | Or even with a literal numeric descriptor: | |
1372 | ||
d12d61cf | 1373 | my $fd = $ENV{MHCONTEXTFD}; |
1374 | open $mhcontext, "<&=$fd"; # like fdopen(3S) | |
68dc0745 | 1375 | |
09c1cbc2 | 1376 | Note that "<&STDIN" makes a copy, but "<&=STDIN" makes |
d12d61cf | 1377 | an alias. That means if you close an aliased handle, all |
1378 | aliases become inaccessible. This is not true with | |
5a964f20 TC |
1379 | a copied one. |
1380 | ||
1381 | Error checking, as always, has been left as an exercise for the reader. | |
68dc0745 | 1382 | |
1383 | =head2 How do I close a file descriptor by number? | |
ee891a00 RGS |
1384 | X<file, closing file descriptors> X<POSIX> X<close> |
1385 | ||
1386 | If, for some reason, you have a file descriptor instead of a | |
1387 | filehandle (perhaps you used C<POSIX::open>), you can use the | |
1388 | C<close()> function from the C<POSIX> module: | |
68dc0745 | 1389 | |
ee891a00 | 1390 | use POSIX (); |
109f0441 | 1391 | |
ee891a00 | 1392 | POSIX::close( $fd ); |
109f0441 | 1393 | |
ac003c96 | 1394 | This should rarely be necessary, as the Perl C<close()> function is to be |
68dc0745 | 1395 | used for things that Perl opened itself, even if it was a dup of a |
d12d61cf | 1396 | numeric descriptor as with C<MHCONTEXT> above. But if you really have |
68dc0745 | 1397 | to, you may be able to do this: |
1398 | ||
500071f4 | 1399 | require 'sys/syscall.ph'; |
d12d61cf | 1400 | my $rc = syscall(&SYS_close, $fd + 0); # must force numeric |
500071f4 | 1401 | die "can't sysclose $fd: $!" unless $rc == -1; |
68dc0745 | 1402 | |
ee891a00 | 1403 | Or, just use the fdopen(3S) feature of C<open()>: |
d92eb7b0 | 1404 | |
500071f4 | 1405 | { |
ee891a00 RGS |
1406 | open my( $fh ), "<&=$fd" or die "Cannot reopen fd=$fd: $!"; |
1407 | close $fh; | |
500071f4 | 1408 | } |
d92eb7b0 | 1409 | |
883f1635 | 1410 | =head2 Why can't I use "C:\temp\foo" in DOS paths? Why doesn't `C:\temp\foo.exe` work? |
d74e8afc | 1411 | X<filename, DOS issues> |
68dc0745 | 1412 | |
1413 | Whoops! You just put a tab and a formfeed into that filename! | |
1414 | Remember that within double quoted strings ("like\this"), the | |
d12d61cf | 1415 | backslash is an escape character. The full list of these is in |
1416 | L<perlop/Quote and Quote-like Operators>. Unsurprisingly, you don't | |
68dc0745 | 1417 | have a file called "c:(tab)emp(formfeed)oo" or |
65acb1b1 | 1418 | "c:(tab)emp(formfeed)oo.exe" on your legacy DOS filesystem. |
68dc0745 | 1419 | |
1420 | Either single-quote your strings, or (preferably) use forward slashes. | |
46fc3d4c | 1421 | Since all DOS and Windows versions since something like MS-DOS 2.0 or so |
68dc0745 | 1422 | have treated C</> and C<\> the same in a path, you might as well use the |
a6dd486b | 1423 | one that doesn't clash with Perl--or the POSIX shell, ANSI C and C++, |
d12d61cf | 1424 | awk, Tcl, Java, or Python, just to mention a few. POSIX paths |
65acb1b1 | 1425 | are more portable, too. |
68dc0745 | 1426 | |
1427 | =head2 Why doesn't glob("*.*") get all the files? | |
d74e8afc | 1428 | X<glob> |
68dc0745 | 1429 | |
1430 | Because even on non-Unix ports, Perl's glob function follows standard | |
d12d61cf | 1431 | Unix globbing semantics. You'll need C<glob("*")> to get all (non-hidden) |
1432 | files. This makes glob() portable even to legacy systems. Your | |
1433 | port may include proprietary globbing functions as well. Check its | |
65acb1b1 | 1434 | documentation for details. |
68dc0745 | 1435 | |
1436 | =head2 Why does Perl let me delete read-only files? Why does C<-i> clobber protected files? Isn't this a bug in Perl? | |
1437 | ||
06a5f41f JH |
1438 | This is elaborately and painstakingly described in the |
1439 | F<file-dir-perms> article in the "Far More Than You Ever Wanted To | |
49d635f9 | 1440 | Know" collection in http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz . |
68dc0745 | 1441 | |
d12d61cf | 1442 | The executive summary: learn how your filesystem works. The |
68dc0745 | 1443 | permissions on a file say what can happen to the data in that file. |
1444 | The permissions on a directory say what can happen to the list of | |
d12d61cf | 1445 | files in that directory. If you delete a file, you're removing its |
68dc0745 | 1446 | name from the directory (so the operation depends on the permissions |
d12d61cf | 1447 | of the directory, not of the file). If you try to write to the file, |
68dc0745 | 1448 | the permissions of the file govern whether you're allowed to. |
1449 | ||
1450 | =head2 How do I select a random line from a file? | |
d74e8afc | 1451 | X<file, selecting a random line> |
68dc0745 | 1452 | |
109f0441 S |
1453 | Short of loading the file into a database or pre-indexing the lines in |
1454 | the file, there are a couple of things that you can do. | |
1455 | ||
1456 | Here's a reservoir-sampling algorithm from the Camel Book: | |
68dc0745 | 1457 | |
500071f4 RGS |
1458 | srand; |
1459 | rand($.) < 1 && ($line = $_) while <>; | |
68dc0745 | 1460 | |
49d635f9 | 1461 | This has a significant advantage in space over reading the whole file |
d12d61cf | 1462 | in. You can find a proof of this method in I<The Art of Computer |
49d635f9 RGS |
1463 | Programming>, Volume 2, Section 3.4.2, by Donald E. Knuth. |
1464 | ||
109f0441 | 1465 | You can use the C<File::Random> module which provides a function |
49d635f9 RGS |
1466 | for that algorithm: |
1467 | ||
1468 | use File::Random qw/random_line/; | |
1469 | my $line = random_line($filename); | |
1470 | ||
109f0441 | 1471 | Another way is to use the C<Tie::File> module, which treats the entire |
d12d61cf | 1472 | file as an array. Simply access a random array element. |
68dc0745 | 1473 | |
65acb1b1 TC |
1474 | =head2 Why do I get weird spaces when I print an array of lines? |
1475 | ||
109f0441 S |
1476 | (contributed by brian d foy) |
1477 | ||
1478 | If you are seeing spaces between the elements of your array when | |
1479 | you print the array, you are probably interpolating the array in | |
1480 | double quotes: | |
1481 | ||
1482 | my @animals = qw(camel llama alpaca vicuna); | |
1483 | print "animals are: @animals\n"; | |
65acb1b1 | 1484 | |
109f0441 S |
1485 | It's the double quotes, not the C<print>, doing this. Whenever you |
1486 | interpolate an array in a double quote context, Perl joins the | |
1487 | elements with spaces (or whatever is in C<$">, which is a space by | |
1488 | default): | |
65acb1b1 | 1489 | |
109f0441 | 1490 | animals are: camel llama alpaca vicuna |
65acb1b1 | 1491 | |
109f0441 | 1492 | This is different than printing the array without the interpolation: |
65acb1b1 | 1493 | |
109f0441 S |
1494 | my @animals = qw(camel llama alpaca vicuna); |
1495 | print "animals are: ", @animals, "\n"; | |
65acb1b1 | 1496 | |
109f0441 S |
1497 | Now the output doesn't have the spaces between the elements because |
1498 | the elements of C<@animals> simply become part of the list to | |
1499 | C<print>: | |
65acb1b1 | 1500 | |
109f0441 S |
1501 | animals are: camelllamaalpacavicuna |
1502 | ||
1503 | You might notice this when each of the elements of C<@array> end with | |
1504 | a newline. You expect to print one element per line, but notice that | |
1505 | every line after the first is indented: | |
1506 | ||
1507 | this is a line | |
1508 | this is another line | |
1509 | this is the third line | |
1510 | ||
1511 | That extra space comes from the interpolation of the array. If you | |
1512 | don't want to put anything between your array elements, don't use the | |
1513 | array in double quotes. You can send it to print without them: | |
65acb1b1 | 1514 | |
500071f4 RGS |
1515 | print @lines; |
1516 | ||
109f0441 S |
1517 | =head2 How do I traverse a directory tree? |
1518 | ||
1519 | (contributed by brian d foy) | |
1520 | ||
1521 | The C<File::Find> module, which comes with Perl, does all of the hard | |
1522 | work to traverse a directory structure. It comes with Perl. You simply | |
1523 | call the C<find> subroutine with a callback subroutine and the | |
1524 | directories you want to traverse: | |
1525 | ||
1526 | use File::Find; | |
1527 | ||
1528 | find( \&wanted, @directories ); | |
1529 | ||
1530 | sub wanted { | |
1531 | # full path in $File::Find::name | |
1532 | # just filename in $_ | |
1533 | ... do whatever you want to do ... | |
1534 | } | |
1535 | ||
1536 | The C<File::Find::Closures>, which you can download from CPAN, provides | |
1537 | many ready-to-use subroutines that you can use with C<File::Find>. | |
1538 | ||
1539 | The C<File::Finder>, which you can download from CPAN, can help you | |
1540 | create the callback subroutine using something closer to the syntax of | |
1541 | the C<find> command-line utility: | |
1542 | ||
1543 | use File::Find; | |
1544 | use File::Finder; | |
1545 | ||
1546 | my $deep_dirs = File::Finder->depth->type('d')->ls->exec('rmdir','{}'); | |
1547 | ||
1548 | find( $deep_dirs->as_options, @places ); | |
1549 | ||
1550 | The C<File::Find::Rule> module, which you can download from CPAN, has | |
1551 | a similar interface, but does the traversal for you too: | |
1552 | ||
1553 | use File::Find::Rule; | |
1554 | ||
1555 | my @files = File::Find::Rule->file() | |
1556 | ->name( '*.pm' ) | |
1557 | ->in( @INC ); | |
1558 | ||
1559 | =head2 How do I delete a directory tree? | |
1560 | ||
1561 | (contributed by brian d foy) | |
1562 | ||
8d2e243f | 1563 | If you have an empty directory, you can use Perl's built-in C<rmdir>. |
1564 | If the directory is not empty (so, no files or subdirectories), you | |
1565 | either have to empty it yourself (a lot of work) or use a module to | |
1566 | help you. | |
109f0441 | 1567 | |
8d2e243f | 1568 | The C<File::Path> module, which comes with Perl, has a C<remove_tree> |
1569 | which can take care of all of the hard work for you: | |
109f0441 | 1570 | |
8d2e243f | 1571 | use File::Path qw(remove_tree); |
109f0441 | 1572 | |
8d2e243f | 1573 | remove_tree( @directories ); |
109f0441 | 1574 | |
8d2e243f | 1575 | The C<File::Path> module also has a legacy interface to the older |
1576 | C<rmtree> subroutine. | |
109f0441 S |
1577 | |
1578 | =head2 How do I copy an entire directory? | |
1579 | ||
1580 | (contributed by Shlomi Fish) | |
1581 | ||
1582 | To do the equivalent of C<cp -R> (i.e. copy an entire directory tree | |
1583 | recursively) in portable Perl, you'll either need to write something yourself | |
1584 | or find a good CPAN module such as L<File::Copy::Recursive>. | |
65acb1b1 | 1585 | |
68dc0745 | 1586 | =head1 AUTHOR AND COPYRIGHT |
1587 | ||
8d2e243f | 1588 | Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington, and |
7678cced | 1589 | other authors as noted. All rights reserved. |
5a964f20 | 1590 | |
5a7beb56 JH |
1591 | This documentation is free; you can redistribute it and/or modify it |
1592 | under the same terms as Perl itself. | |
c8db1d39 | 1593 | |
87275199 | 1594 | Irrespective of its distribution, all code examples here are in the public |
d12d61cf | 1595 | domain. You are permitted and encouraged to use this code and any |
c8db1d39 | 1596 | derivatives thereof in your own programs for fun or for profit as you |
d12d61cf | 1597 | see fit. A simple comment in the code giving credit to the FAQ would |
c8db1d39 | 1598 | be courteous but is not required. |