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