Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | =head1 NAME |
2 | ||
3 | perlfaq5 - Files and Formats ($Revision: 1.18 $, $Date: 2002/05/30 07:04:25 $) | |
4 | ||
5 | =head1 DESCRIPTION | |
6 | ||
7 | This section deals with I/O and the "f" issues: filehandles, flushing, | |
8 | formats, and footers. | |
9 | ||
10 | =head2 How do I flush/unbuffer an output filehandle? Why must I do this? | |
11 | ||
12 | Perl does not support truly unbuffered output (except | |
13 | insofar as you can C<syswrite(OUT, $char, 1)>), although it | |
14 | does support is "command buffering", in which a physical | |
15 | write is performed after every output command. | |
16 | ||
17 | The C standard I/O library (stdio) normally buffers | |
18 | characters sent to devices so that there isn't a system call | |
19 | for each byte. In most stdio implementations, the type of | |
20 | output buffering and the size of the buffer varies according | |
21 | to the type of device. Perl's print() and write() functions | |
22 | normally buffer output, while syswrite() bypasses buffering | |
23 | all together. | |
24 | ||
25 | If you want your output to be sent immediately when you | |
26 | execute print() or write() (for instance, for some network | |
27 | protocols), you must set the handle's autoflush flag. This | |
28 | flag is the Perl variable $| and when it is set to a true | |
29 | value, Perl will flush the handle's buffer after each | |
30 | print() or write(). Setting $| affects buffering only for | |
31 | the currently selected default file handle. You choose this | |
32 | handle with the one argument select() call (see | |
33 | L<perlvar/$|> and L<perlfunc/select>). | |
34 | ||
35 | Use select() to choose the desired handle, then set its | |
36 | per-filehandle variables. | |
37 | ||
38 | $old_fh = select(OUTPUT_HANDLE); | |
39 | $| = 1; | |
40 | select($old_fh); | |
41 | ||
42 | Some idioms can handle this in a single statement: | |
43 | ||
44 | select((select(OUTPUT_HANDLE), $| = 1)[0]); | |
45 | ||
46 | $| = 1, select $_ for select OUTPUT_HANDLE; | |
47 | ||
48 | Some modules offer object-oriented access to handles and their | |
49 | variables, although they may be overkill if this is the only | |
50 | thing you do with them. You can use IO::Handle: | |
51 | ||
52 | use IO::Handle; | |
53 | open(DEV, ">/dev/printer"); # but is this? | |
54 | DEV->autoflush(1); | |
55 | ||
56 | or IO::Socket: | |
57 | ||
58 | use IO::Socket; # this one is kinda a pipe? | |
59 | my $sock = IO::Socket::INET->new( 'www.example.com:80' ) ; | |
60 | ||
61 | $sock->autoflush(); | |
62 | ||
63 | =head2 How do I change one line in a file/delete a line in a file/insert a line in the middle of a file/append to the beginning of a file? | |
64 | ||
65 | Use the Tie::File module, which is included in the standard | |
66 | distribution since Perl 5.8.0. | |
67 | ||
68 | =head2 How do I count the number of lines in a file? | |
69 | ||
70 | One fairly efficient way is to count newlines in the file. The | |
71 | following program uses a feature of tr///, as documented in L<perlop>. | |
72 | If your text file doesn't end with a newline, then it's not really a | |
73 | proper text file, so this may report one fewer line than you expect. | |
74 | ||
75 | $lines = 0; | |
76 | open(FILE, $filename) or die "Can't open `$filename': $!"; | |
77 | while (sysread FILE, $buffer, 4096) { | |
78 | $lines += ($buffer =~ tr/\n//); | |
79 | } | |
80 | close FILE; | |
81 | ||
82 | This assumes no funny games with newline translations. | |
83 | ||
84 | =head2 How do I make a temporary file name? | |
85 | ||
86 | Use the File::Temp module, see L<File::Temp> for more information. | |
87 | ||
88 | use File::Temp qw/ tempfile tempdir /; | |
89 | ||
90 | $dir = tempdir( CLEANUP => 1 ); | |
91 | ($fh, $filename) = tempfile( DIR => $dir ); | |
92 | ||
93 | # or if you don't need to know the filename | |
94 | ||
95 | $fh = tempfile( DIR => $dir ); | |
96 | ||
97 | The File::Temp has been a standard module since Perl 5.6.1. If you | |
98 | don't have a modern enough Perl installed, use the C<new_tmpfile> | |
99 | class method from the IO::File module to get a filehandle opened for | |
100 | reading and writing. Use it if you don't need to know the file's name: | |
101 | ||
102 | use IO::File; | |
103 | $fh = IO::File->new_tmpfile() | |
104 | or die "Unable to make new temporary file: $!"; | |
105 | ||
106 | If you're committed to creating a temporary file by hand, use the | |
107 | process ID and/or the current time-value. If you need to have many | |
108 | temporary files in one process, use a counter: | |
109 | ||
110 | BEGIN { | |
111 | use Fcntl; | |
112 | my $temp_dir = -d '/tmp' ? '/tmp' : $ENV{TMPDIR} || $ENV{TEMP}; | |
113 | my $base_name = sprintf("%s/%d-%d-0000", $temp_dir, $$, time()); | |
114 | sub temp_file { | |
115 | local *FH; | |
116 | my $count = 0; | |
117 | until (defined(fileno(FH)) || $count++ > 100) { | |
118 | $base_name =~ s/-(\d+)$/"-" . (1 + $1)/e; | |
119 | sysopen(FH, $base_name, O_WRONLY|O_EXCL|O_CREAT); | |
120 | } | |
121 | if (defined(fileno(FH)) | |
122 | return (*FH, $base_name); | |
123 | } else { | |
124 | return (); | |
125 | } | |
126 | } | |
127 | } | |
128 | ||
129 | =head2 How can I manipulate fixed-record-length files? | |
130 | ||
131 | The most efficient way is using pack() and unpack(). This is faster than | |
132 | using substr() when taking many, many strings. It is slower for just a few. | |
133 | ||
134 | Here is a sample chunk of code to break up and put back together again | |
135 | some fixed-format input lines, in this case from the output of a normal, | |
136 | Berkeley-style ps: | |
137 | ||
138 | # sample input line: | |
139 | # 15158 p5 T 0:00 perl /home/tchrist/scripts/now-what | |
140 | $PS_T = 'A6 A4 A7 A5 A*'; | |
141 | open(PS, "ps|"); | |
142 | print scalar <PS>; | |
143 | while (<PS>) { | |
144 | ($pid, $tt, $stat, $time, $command) = unpack($PS_T, $_); | |
145 | for $var (qw!pid tt stat time command!) { | |
146 | print "$var: <$$var>\n"; | |
147 | } | |
148 | print 'line=', pack($PS_T, $pid, $tt, $stat, $time, $command), | |
149 | "\n"; | |
150 | } | |
151 | ||
152 | We've used C<$$var> in a way that forbidden by C<use strict 'refs'>. | |
153 | That is, we've promoted a string to a scalar variable reference using | |
154 | symbolic references. This is okay in small programs, but doesn't scale | |
155 | well. It also only works on global variables, not lexicals. | |
156 | ||
157 | =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? | |
158 | ||
159 | As of perl5.6, open() autovivifies file and directory handles | |
160 | as references if you pass it an uninitialized scalar variable. | |
161 | You can then pass these references just like any other scalar, | |
162 | and use them in the place of named handles. | |
163 | ||
164 | open my $fh, $file_name; | |
165 | ||
166 | open local $fh, $file_name; | |
167 | ||
168 | print $fh "Hello World!\n"; | |
169 | ||
170 | process_file( $fh ); | |
171 | ||
172 | Before perl5.6, you had to deal with various typeglob idioms | |
173 | which you may see in older code. | |
174 | ||
175 | open FILE, "> $filename"; | |
176 | process_typeglob( *FILE ); | |
177 | process_reference( \*FILE ); | |
178 | ||
179 | sub process_typeglob { local *FH = shift; print FH "Typeglob!" } | |
180 | sub process_reference { local $fh = shift; print $fh "Reference!" } | |
181 | ||
182 | If you want to create many anonymous handles, you should | |
183 | check out the Symbol or IO::Handle modules. | |
184 | ||
185 | =head2 How can I use a filehandle indirectly? | |
186 | ||
187 | An indirect filehandle is using something other than a symbol | |
188 | in a place that a filehandle is expected. Here are ways | |
189 | to get indirect filehandles: | |
190 | ||
191 | $fh = SOME_FH; # bareword is strict-subs hostile | |
192 | $fh = "SOME_FH"; # strict-refs hostile; same package only | |
193 | $fh = *SOME_FH; # typeglob | |
194 | $fh = \*SOME_FH; # ref to typeglob (bless-able) | |
195 | $fh = *SOME_FH{IO}; # blessed IO::Handle from *SOME_FH typeglob | |
196 | ||
197 | Or, you can use the C<new> method from one of the IO::* modules to | |
198 | create an anonymous filehandle, store that in a scalar variable, | |
199 | and use it as though it were a normal filehandle. | |
200 | ||
201 | use IO::Handle; # 5.004 or higher | |
202 | $fh = IO::Handle->new(); | |
203 | ||
204 | Then use any of those as you would a normal filehandle. Anywhere that | |
205 | Perl is expecting a filehandle, an indirect filehandle may be used | |
206 | instead. An indirect filehandle is just a scalar variable that contains | |
207 | a filehandle. Functions like C<print>, C<open>, C<seek>, or | |
208 | the C<< <FH> >> diamond operator will accept either a named filehandle | |
209 | or a scalar variable containing one: | |
210 | ||
211 | ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR); | |
212 | print $ofh "Type it: "; | |
213 | $got = <$ifh> | |
214 | print $efh "What was that: $got"; | |
215 | ||
216 | If you're passing a filehandle to a function, you can write | |
217 | the function in two ways: | |
218 | ||
219 | sub accept_fh { | |
220 | my $fh = shift; | |
221 | print $fh "Sending to indirect filehandle\n"; | |
222 | } | |
223 | ||
224 | Or it can localize a typeglob and use the filehandle directly: | |
225 | ||
226 | sub accept_fh { | |
227 | local *FH = shift; | |
228 | print FH "Sending to localized filehandle\n"; | |
229 | } | |
230 | ||
231 | Both styles work with either objects or typeglobs of real filehandles. | |
232 | (They might also work with strings under some circumstances, but this | |
233 | is risky.) | |
234 | ||
235 | accept_fh(*STDOUT); | |
236 | accept_fh($handle); | |
237 | ||
238 | In the examples above, we assigned the filehandle to a scalar variable | |
239 | before using it. That is because only simple scalar variables, not | |
240 | expressions or subscripts of hashes or arrays, can be used with | |
241 | built-ins like C<print>, C<printf>, or the diamond operator. Using | |
242 | something other than a simple scalar variable as a filehandle is | |
243 | illegal and won't even compile: | |
244 | ||
245 | @fd = (*STDIN, *STDOUT, *STDERR); | |
246 | print $fd[1] "Type it: "; # WRONG | |
247 | $got = <$fd[0]> # WRONG | |
248 | print $fd[2] "What was that: $got"; # WRONG | |
249 | ||
250 | With C<print> and C<printf>, you get around this by using a block and | |
251 | an expression where you would place the filehandle: | |
252 | ||
253 | print { $fd[1] } "funny stuff\n"; | |
254 | printf { $fd[1] } "Pity the poor %x.\n", 3_735_928_559; | |
255 | # Pity the poor deadbeef. | |
256 | ||
257 | That block is a proper block like any other, so you can put more | |
258 | complicated code there. This sends the message out to one of two places: | |
259 | ||
260 | $ok = -x "/bin/cat"; | |
261 | print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n"; | |
262 | print { $fd[ 1+ ($ok || 0) ] } "cat stat $ok\n"; | |
263 | ||
264 | This approach of treating C<print> and C<printf> like object methods | |
265 | calls doesn't work for the diamond operator. That's because it's a | |
266 | real operator, not just a function with a comma-less argument. Assuming | |
267 | you've been storing typeglobs in your structure as we did above, you | |
268 | can use the built-in function named C<readline> to read a record just | |
269 | as C<< <> >> does. Given the initialization shown above for @fd, this | |
270 | would work, but only because readline() requires a typeglob. It doesn't | |
271 | work with objects or strings, which might be a bug we haven't fixed yet. | |
272 | ||
273 | $got = readline($fd[0]); | |
274 | ||
275 | Let it be noted that the flakiness of indirect filehandles is not | |
276 | related to whether they're strings, typeglobs, objects, or anything else. | |
277 | It's the syntax of the fundamental operators. Playing the object | |
278 | game doesn't help you at all here. | |
279 | ||
280 | =head2 How can I set up a footer format to be used with write()? | |
281 | ||
282 | There's no builtin way to do this, but L<perlform> has a couple of | |
283 | techniques to make it possible for the intrepid hacker. | |
284 | ||
285 | =head2 How can I write() into a string? | |
286 | ||
287 | See L<perlform/"Accessing Formatting Internals"> for an swrite() function. | |
288 | ||
289 | =head2 How can I output my numbers with commas added? | |
290 | ||
291 | This one from Benjamin Goldberg will do it for you: | |
292 | ||
293 | s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g; | |
294 | ||
295 | or written verbosely: | |
296 | ||
297 | s/( | |
298 | ^[-+]? # beginning of number. | |
299 | \d{1,3}? # first digits before first comma | |
300 | (?= # followed by, (but not included in the match) : | |
301 | (?>(?:\d{3})+) # some positive multiple of three digits. | |
302 | (?!\d) # an *exact* multiple, not x * 3 + 1 or whatever. | |
303 | ) | |
304 | | # or: | |
305 | \G\d{3} # after the last group, get three digits | |
306 | (?=\d) # but they have to have more digits after them. | |
307 | )/$1,/xg; | |
308 | ||
309 | =head2 How can I translate tildes (~) in a filename? | |
310 | ||
311 | Use the <> (glob()) operator, documented in L<perlfunc>. Older | |
312 | versions of Perl require that you have a shell installed that groks | |
313 | tildes. Recent perl versions have this feature built in. The | |
314 | File::KGlob module (available from CPAN) gives more portable glob | |
315 | functionality. | |
316 | ||
317 | Within Perl, you may use this directly: | |
318 | ||
319 | $filename =~ s{ | |
320 | ^ ~ # find a leading tilde | |
321 | ( # save this in $1 | |
322 | [^/] # a non-slash character | |
323 | * # repeated 0 or more times (0 means me) | |
324 | ) | |
325 | }{ | |
326 | $1 | |
327 | ? (getpwnam($1))[7] | |
328 | : ( $ENV{HOME} || $ENV{LOGDIR} ) | |
329 | }ex; | |
330 | ||
331 | =head2 How come when I open a file read-write it wipes it out? | |
332 | ||
333 | Because you're using something like this, which truncates the file and | |
334 | I<then> gives you read-write access: | |
335 | ||
336 | open(FH, "+> /path/name"); # WRONG (almost always) | |
337 | ||
338 | Whoops. You should instead use this, which will fail if the file | |
339 | doesn't exist. | |
340 | ||
341 | open(FH, "+< /path/name"); # open for update | |
342 | ||
343 | Using ">" always clobbers or creates. Using "<" never does | |
344 | either. The "+" doesn't change this. | |
345 | ||
346 | Here are examples of many kinds of file opens. Those using sysopen() | |
347 | all assume | |
348 | ||
349 | use Fcntl; | |
350 | ||
351 | To open file for reading: | |
352 | ||
353 | open(FH, "< $path") || die $!; | |
354 | sysopen(FH, $path, O_RDONLY) || die $!; | |
355 | ||
356 | To open file for writing, create new file if needed or else truncate old file: | |
357 | ||
358 | open(FH, "> $path") || die $!; | |
359 | sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT) || die $!; | |
360 | sysopen(FH, $path, O_WRONLY|O_TRUNC|O_CREAT, 0666) || die $!; | |
361 | ||
362 | To open file for writing, create new file, file must not exist: | |
363 | ||
364 | sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT) || die $!; | |
365 | sysopen(FH, $path, O_WRONLY|O_EXCL|O_CREAT, 0666) || die $!; | |
366 | ||
367 | To open file for appending, create if necessary: | |
368 | ||
369 | open(FH, ">> $path") || die $!; | |
370 | sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT) || die $!; | |
371 | sysopen(FH, $path, O_WRONLY|O_APPEND|O_CREAT, 0666) || die $!; | |
372 | ||
373 | To open file for appending, file must exist: | |
374 | ||
375 | sysopen(FH, $path, O_WRONLY|O_APPEND) || die $!; | |
376 | ||
377 | To open file for update, file must exist: | |
378 | ||
379 | open(FH, "+< $path") || die $!; | |
380 | sysopen(FH, $path, O_RDWR) || die $!; | |
381 | ||
382 | To open file for update, create file if necessary: | |
383 | ||
384 | sysopen(FH, $path, O_RDWR|O_CREAT) || die $!; | |
385 | sysopen(FH, $path, O_RDWR|O_CREAT, 0666) || die $!; | |
386 | ||
387 | To open file for update, file must not exist: | |
388 | ||
389 | sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT) || die $!; | |
390 | sysopen(FH, $path, O_RDWR|O_EXCL|O_CREAT, 0666) || die $!; | |
391 | ||
392 | To open a file without blocking, creating if necessary: | |
393 | ||
394 | sysopen(FH, "/tmp/somefile", O_WRONLY|O_NDELAY|O_CREAT) | |
395 | or die "can't open /tmp/somefile: $!": | |
396 | ||
397 | Be warned that neither creation nor deletion of files is guaranteed to | |
398 | be an atomic operation over NFS. That is, two processes might both | |
399 | successfully create or unlink the same file! Therefore O_EXCL | |
400 | isn't as exclusive as you might wish. | |
401 | ||
402 | See also the new L<perlopentut> if you have it (new for 5.6). | |
403 | ||
404 | =head2 Why do I sometimes get an "Argument list too long" when I use <*>? | |
405 | ||
406 | The C<< <> >> operator performs a globbing operation (see above). | |
407 | In Perl versions earlier than v5.6.0, the internal glob() operator forks | |
408 | csh(1) to do the actual glob expansion, but | |
409 | csh can't handle more than 127 items and so gives the error message | |
410 | C<Argument list too long>. People who installed tcsh as csh won't | |
411 | have this problem, but their users may be surprised by it. | |
412 | ||
413 | To get around this, either upgrade to Perl v5.6.0 or later, do the glob | |
414 | yourself with readdir() and patterns, or use a module like File::KGlob, | |
415 | one that doesn't use the shell to do globbing. | |
416 | ||
417 | =head2 Is there a leak/bug in glob()? | |
418 | ||
419 | Due to the current implementation on some operating systems, when you | |
420 | use the glob() function or its angle-bracket alias in a scalar | |
421 | context, you may cause a memory leak and/or unpredictable behavior. It's | |
422 | best therefore to use glob() only in list context. | |
423 | ||
424 | =head2 How can I open a file with a leading ">" or trailing blanks? | |
425 | ||
426 | Normally perl ignores trailing blanks in filenames, and interprets | |
427 | certain leading characters (or a trailing "|") to mean something | |
428 | special. | |
429 | ||
430 | The three argument form of open() lets you specify the mode | |
431 | separately from the filename. The open() function treats | |
432 | special mode characters and whitespace in the filename as | |
433 | literals | |
434 | ||
435 | open FILE, "<", " file "; # filename is " file " | |
436 | open FILE, ">", ">file"; # filename is ">file" | |
437 | ||
438 | It may be a lot clearer to use sysopen(), though: | |
439 | ||
440 | use Fcntl; | |
441 | $badpath = "<<<something really wicked "; | |
442 | sysopen (FH, $badpath, O_WRONLY | O_CREAT | O_TRUNC) | |
443 | or die "can't open $badpath: $!"; | |
444 | ||
445 | =head2 How can I reliably rename a file? | |
446 | ||
447 | If your operating system supports a proper mv(1) utility or its functional | |
448 | equivalent, this works: | |
449 | ||
450 | rename($old, $new) or system("mv", $old, $new); | |
451 | ||
452 | It may be more portable to use the File::Copy module instead. | |
453 | You just copy to the new file to the new name (checking return | |
454 | values), then delete the old one. This isn't really the same | |
455 | semantically as a rename(), which preserves meta-information like | |
456 | permissions, timestamps, inode info, etc. | |
457 | ||
458 | Newer versions of File::Copy export a move() function. | |
459 | ||
460 | =head2 How can I lock a file? | |
461 | ||
462 | Perl's builtin flock() function (see L<perlfunc> for details) will call | |
463 | flock(2) if that exists, fcntl(2) if it doesn't (on perl version 5.004 and | |
464 | later), and lockf(3) if neither of the two previous system calls exists. | |
465 | On some systems, it may even use a different form of native locking. | |
466 | Here are some gotchas with Perl's flock(): | |
467 | ||
468 | =over 4 | |
469 | ||
470 | =item 1 | |
471 | ||
472 | Produces a fatal error if none of the three system calls (or their | |
473 | close equivalent) exists. | |
474 | ||
475 | =item 2 | |
476 | ||
477 | lockf(3) does not provide shared locking, and requires that the | |
478 | filehandle be open for writing (or appending, or read/writing). | |
479 | ||
480 | =item 3 | |
481 | ||
482 | Some versions of flock() can't lock files over a network (e.g. on NFS file | |
483 | systems), so you'd need to force the use of fcntl(2) when you build Perl. | |
484 | But even this is dubious at best. See the flock entry of L<perlfunc> | |
485 | and the F<INSTALL> file in the source distribution for information on | |
486 | building Perl to do this. | |
487 | ||
488 | Two potentially non-obvious but traditional flock semantics are that | |
489 | it waits indefinitely until the lock is granted, and that its locks are | |
490 | I<merely advisory>. Such discretionary locks are more flexible, but | |
491 | offer fewer guarantees. This means that files locked with flock() may | |
492 | be modified by programs that do not also use flock(). Cars that stop | |
493 | for red lights get on well with each other, but not with cars that don't | |
494 | stop for red lights. See the perlport manpage, your port's specific | |
495 | documentation, or your system-specific local manpages for details. It's | |
496 | best to assume traditional behavior if you're writing portable programs. | |
497 | (If you're not, you should as always feel perfectly free to write | |
498 | for your own system's idiosyncrasies (sometimes called "features"). | |
499 | Slavish adherence to portability concerns shouldn't get in the way of | |
500 | your getting your job done.) | |
501 | ||
502 | For more information on file locking, see also | |
503 | L<perlopentut/"File Locking"> if you have it (new for 5.6). | |
504 | ||
505 | =back | |
506 | ||
507 | =head2 Why can't I just open(FH, ">file.lock")? | |
508 | ||
509 | A common bit of code B<NOT TO USE> is this: | |
510 | ||
511 | sleep(3) while -e "file.lock"; # PLEASE DO NOT USE | |
512 | open(LCK, "> file.lock"); # THIS BROKEN CODE | |
513 | ||
514 | This is a classic race condition: you take two steps to do something | |
515 | which must be done in one. That's why computer hardware provides an | |
516 | atomic test-and-set instruction. In theory, this "ought" to work: | |
517 | ||
518 | sysopen(FH, "file.lock", O_WRONLY|O_EXCL|O_CREAT) | |
519 | or die "can't open file.lock: $!": | |
520 | ||
521 | except that lamentably, file creation (and deletion) is not atomic | |
522 | over NFS, so this won't work (at least, not every time) over the net. | |
523 | Various schemes involving link() have been suggested, but | |
524 | these tend to involve busy-wait, which is also subdesirable. | |
525 | ||
526 | =head2 I still don't get locking. I just want to increment the number in the file. How can I do this? | |
527 | ||
528 | Didn't anyone ever tell you web-page hit counters were useless? | |
529 | They don't count number of hits, they're a waste of time, and they serve | |
530 | only to stroke the writer's vanity. It's better to pick a random number; | |
531 | they're more realistic. | |
532 | ||
533 | Anyway, this is what you can do if you can't help yourself. | |
534 | ||
535 | use Fcntl qw(:DEFAULT :flock); | |
536 | sysopen(FH, "numfile", O_RDWR|O_CREAT) or die "can't open numfile: $!"; | |
537 | flock(FH, LOCK_EX) or die "can't flock numfile: $!"; | |
538 | $num = <FH> || 0; | |
539 | seek(FH, 0, 0) or die "can't rewind numfile: $!"; | |
540 | truncate(FH, 0) or die "can't truncate numfile: $!"; | |
541 | (print FH $num+1, "\n") or die "can't write numfile: $!"; | |
542 | close FH or die "can't close numfile: $!"; | |
543 | ||
544 | Here's a much better web-page hit counter: | |
545 | ||
546 | $hits = int( (time() - 850_000_000) / rand(1_000) ); | |
547 | ||
548 | If the count doesn't impress your friends, then the code might. :-) | |
549 | ||
550 | =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? | |
551 | ||
552 | If you are on a system that correctly implements flock() and you use the | |
553 | example appending code from "perldoc -f flock" everything will be OK | |
554 | even if the OS you are on doesn't implement append mode correctly (if | |
555 | such a system exists.) So if you are happy to restrict yourself to OSs | |
556 | that implement flock() (and that's not really much of a restriction) | |
557 | then that is what you should do. | |
558 | ||
559 | If you know you are only going to use a system that does correctly | |
560 | implement appending (i.e. not Win32) then you can omit the seek() from | |
561 | the above code. | |
562 | ||
563 | If you know you are only writing code to run on an OS and filesystem that | |
564 | does implement append mode correctly (a local filesystem on a modern | |
565 | Unix for example), and you keep the file in block-buffered mode and you | |
566 | write less than one buffer-full of output between each manual flushing | |
567 | of the buffer then each bufferload is almost guaranteed to be written to | |
568 | the end of the file in one chunk without getting intermingled with | |
569 | anyone else's output. You can also use the syswrite() function which is | |
570 | simply a wrapper around your systems write(2) system call. | |
571 | ||
572 | There is still a small theoretical chance that a signal will interrupt | |
573 | the system level write() operation before completion. There is also a | |
574 | possibility that some STDIO implementations may call multiple system | |
575 | level write()s even if the buffer was empty to start. There may be some | |
576 | systems where this probability is reduced to zero. | |
577 | ||
578 | =head2 How do I randomly update a binary file? | |
579 | ||
580 | If you're just trying to patch a binary, in many cases something as | |
581 | simple as this works: | |
582 | ||
583 | perl -i -pe 's{window manager}{window mangler}g' /usr/bin/emacs | |
584 | ||
585 | However, if you have fixed sized records, then you might do something more | |
586 | like this: | |
587 | ||
588 | $RECSIZE = 220; # size of record, in bytes | |
589 | $recno = 37; # which record to update | |
590 | open(FH, "+<somewhere") || die "can't update somewhere: $!"; | |
591 | seek(FH, $recno * $RECSIZE, 0); | |
592 | read(FH, $record, $RECSIZE) == $RECSIZE || die "can't read record $recno: $!"; | |
593 | # munge the record | |
594 | seek(FH, -$RECSIZE, 1); | |
595 | print FH $record; | |
596 | close FH; | |
597 | ||
598 | Locking and error checking are left as an exercise for the reader. | |
599 | Don't forget them or you'll be quite sorry. | |
600 | ||
601 | =head2 How do I get a file's timestamp in perl? | |
602 | ||
603 | If you want to retrieve the time at which the file was last | |
604 | read, written, or had its meta-data (owner, etc) changed, | |
605 | you use the B<-M>, B<-A>, or B<-C> file test operations as | |
606 | documented in L<perlfunc>. These retrieve the age of the | |
607 | file (measured against the start-time of your program) in | |
608 | days as a floating point number. Some platforms may not have | |
609 | all of these times. See L<perlport> for details. To | |
610 | retrieve the "raw" time in seconds since the epoch, you | |
611 | would call the stat function, then use localtime(), | |
612 | gmtime(), or POSIX::strftime() to convert this into | |
613 | human-readable form. | |
614 | ||
615 | Here's an example: | |
616 | ||
617 | $write_secs = (stat($file))[9]; | |
618 | printf "file %s updated at %s\n", $file, | |
619 | scalar localtime($write_secs); | |
620 | ||
621 | If you prefer something more legible, use the File::stat module | |
622 | (part of the standard distribution in version 5.004 and later): | |
623 | ||
624 | # error checking left as an exercise for reader. | |
625 | use File::stat; | |
626 | use Time::localtime; | |
627 | $date_string = ctime(stat($file)->mtime); | |
628 | print "file $file updated at $date_string\n"; | |
629 | ||
630 | The POSIX::strftime() approach has the benefit of being, | |
631 | in theory, independent of the current locale. See L<perllocale> | |
632 | for details. | |
633 | ||
634 | =head2 How do I set a file's timestamp in perl? | |
635 | ||
636 | You use the utime() function documented in L<perlfunc/utime>. | |
637 | By way of example, here's a little program that copies the | |
638 | read and write times from its first argument to all the rest | |
639 | of them. | |
640 | ||
641 | if (@ARGV < 2) { | |
642 | die "usage: cptimes timestamp_file other_files ...\n"; | |
643 | } | |
644 | $timestamp = shift; | |
645 | ($atime, $mtime) = (stat($timestamp))[8,9]; | |
646 | utime $atime, $mtime, @ARGV; | |
647 | ||
648 | Error checking is, as usual, left as an exercise for the reader. | |
649 | ||
650 | Note that utime() currently doesn't work correctly with Win95/NT | |
651 | ports. A bug has been reported. Check it carefully before using | |
652 | utime() on those platforms. | |
653 | ||
654 | =head2 How do I print to more than one file at once? | |
655 | ||
656 | If you only have to do this once, you can do this: | |
657 | ||
658 | for $fh (FH1, FH2, FH3) { print $fh "whatever\n" } | |
659 | ||
660 | To connect up to one filehandle to several output filehandles, it's | |
661 | easiest to use the tee(1) program if you have it, and let it take care | |
662 | of the multiplexing: | |
663 | ||
664 | open (FH, "| tee file1 file2 file3"); | |
665 | ||
666 | Or even: | |
667 | ||
668 | # make STDOUT go to three files, plus original STDOUT | |
669 | open (STDOUT, "| tee file1 file2 file3") or die "Teeing off: $!\n"; | |
670 | print "whatever\n" or die "Writing: $!\n"; | |
671 | close(STDOUT) or die "Closing: $!\n"; | |
672 | ||
673 | Otherwise you'll have to write your own multiplexing print | |
674 | function--or your own tee program--or use Tom Christiansen's, | |
675 | at http://www.cpan.org/authors/id/TOMC/scripts/tct.gz , which is | |
676 | written in Perl and offers much greater functionality | |
677 | than the stock version. | |
678 | ||
679 | =head2 How can I read in an entire file all at once? | |
680 | ||
681 | The customary Perl approach for processing all the lines in a file is to | |
682 | do so one line at a time: | |
683 | ||
684 | open (INPUT, $file) || die "can't open $file: $!"; | |
685 | while (<INPUT>) { | |
686 | chomp; | |
687 | # do something with $_ | |
688 | } | |
689 | close(INPUT) || die "can't close $file: $!"; | |
690 | ||
691 | This is tremendously more efficient than reading the entire file into | |
692 | memory as an array of lines and then processing it one element at a time, | |
693 | which is often--if not almost always--the wrong approach. Whenever | |
694 | you see someone do this: | |
695 | ||
696 | @lines = <INPUT>; | |
697 | ||
698 | you should think long and hard about why you need everything loaded at | |
699 | once. It's just not a scalable solution. You might also find it more | |
700 | fun to use the standard Tie::File module, or the DB_File module's | |
701 | $DB_RECNO bindings, which allow you to tie an array to a file so that | |
702 | accessing an element the array actually accesses the corresponding | |
703 | line in the file. | |
704 | ||
705 | You can read the entire filehandle contents into a scalar. | |
706 | ||
707 | { | |
708 | local(*INPUT, $/); | |
709 | open (INPUT, $file) || die "can't open $file: $!"; | |
710 | $var = <INPUT>; | |
711 | } | |
712 | ||
713 | That temporarily undefs your record separator, and will automatically | |
714 | close the file at block exit. If the file is already open, just use this: | |
715 | ||
716 | $var = do { local $/; <INPUT> }; | |
717 | ||
718 | For ordinary files you can also use the read function. | |
719 | ||
720 | read( INPUT, $var, -s INPUT ); | |
721 | ||
722 | The third argument tests the byte size of the data on the INPUT filehandle | |
723 | and reads that many bytes into the buffer $var. | |
724 | ||
725 | =head2 How can I read in a file by paragraphs? | |
726 | ||
727 | Use the C<$/> variable (see L<perlvar> for details). You can either | |
728 | set it to C<""> to eliminate empty paragraphs (C<"abc\n\n\n\ndef">, | |
729 | for instance, gets treated as two paragraphs and not three), or | |
730 | C<"\n\n"> to accept empty paragraphs. | |
731 | ||
732 | Note that a blank line must have no blanks in it. Thus | |
733 | S<C<"fred\n \nstuff\n\n">> is one paragraph, but C<"fred\n\nstuff\n\n"> is two. | |
734 | ||
735 | =head2 How can I read a single character from a file? From the keyboard? | |
736 | ||
737 | You can use the builtin C<getc()> function for most filehandles, but | |
738 | it won't (easily) work on a terminal device. For STDIN, either use | |
739 | the Term::ReadKey module from CPAN or use the sample code in | |
740 | L<perlfunc/getc>. | |
741 | ||
742 | If your system supports the portable operating system programming | |
743 | interface (POSIX), you can use the following code, which you'll note | |
744 | turns off echo processing as well. | |
745 | ||
746 | #!/usr/bin/perl -w | |
747 | use strict; | |
748 | $| = 1; | |
749 | for (1..4) { | |
750 | my $got; | |
751 | print "gimme: "; | |
752 | $got = getone(); | |
753 | print "--> $got\n"; | |
754 | } | |
755 | exit; | |
756 | ||
757 | BEGIN { | |
758 | use POSIX qw(:termios_h); | |
759 | ||
760 | my ($term, $oterm, $echo, $noecho, $fd_stdin); | |
761 | ||
762 | $fd_stdin = fileno(STDIN); | |
763 | ||
764 | $term = POSIX::Termios->new(); | |
765 | $term->getattr($fd_stdin); | |
766 | $oterm = $term->getlflag(); | |
767 | ||
768 | $echo = ECHO | ECHOK | ICANON; | |
769 | $noecho = $oterm & ~$echo; | |
770 | ||
771 | sub cbreak { | |
772 | $term->setlflag($noecho); | |
773 | $term->setcc(VTIME, 1); | |
774 | $term->setattr($fd_stdin, TCSANOW); | |
775 | } | |
776 | ||
777 | sub cooked { | |
778 | $term->setlflag($oterm); | |
779 | $term->setcc(VTIME, 0); | |
780 | $term->setattr($fd_stdin, TCSANOW); | |
781 | } | |
782 | ||
783 | sub getone { | |
784 | my $key = ''; | |
785 | cbreak(); | |
786 | sysread(STDIN, $key, 1); | |
787 | cooked(); | |
788 | return $key; | |
789 | } | |
790 | ||
791 | } | |
792 | ||
793 | END { cooked() } | |
794 | ||
795 | The Term::ReadKey module from CPAN may be easier to use. Recent versions | |
796 | include also support for non-portable systems as well. | |
797 | ||
798 | use Term::ReadKey; | |
799 | open(TTY, "</dev/tty"); | |
800 | print "Gimme a char: "; | |
801 | ReadMode "raw"; | |
802 | $key = ReadKey 0, *TTY; | |
803 | ReadMode "normal"; | |
804 | printf "\nYou said %s, char number %03d\n", | |
805 | $key, ord $key; | |
806 | ||
807 | =head2 How can I tell whether there's a character waiting on a filehandle? | |
808 | ||
809 | The very first thing you should do is look into getting the Term::ReadKey | |
810 | extension from CPAN. As we mentioned earlier, it now even has limited | |
811 | support for non-portable (read: not open systems, closed, proprietary, | |
812 | not POSIX, not Unix, etc) systems. | |
813 | ||
814 | You should also check out the Frequently Asked Questions list in | |
815 | comp.unix.* for things like this: the answer is essentially the same. | |
816 | It's very system dependent. Here's one solution that works on BSD | |
817 | systems: | |
818 | ||
819 | sub key_ready { | |
820 | my($rin, $nfd); | |
821 | vec($rin, fileno(STDIN), 1) = 1; | |
822 | return $nfd = select($rin,undef,undef,0); | |
823 | } | |
824 | ||
825 | If you want to find out how many characters are waiting, there's | |
826 | also the FIONREAD ioctl call to be looked at. The I<h2ph> tool that | |
827 | comes with Perl tries to convert C include files to Perl code, which | |
828 | can be C<require>d. FIONREAD ends up defined as a function in the | |
829 | I<sys/ioctl.ph> file: | |
830 | ||
831 | require 'sys/ioctl.ph'; | |
832 | ||
833 | $size = pack("L", 0); | |
834 | ioctl(FH, FIONREAD(), $size) or die "Couldn't call ioctl: $!\n"; | |
835 | $size = unpack("L", $size); | |
836 | ||
837 | If I<h2ph> wasn't installed or doesn't work for you, you can | |
838 | I<grep> the include files by hand: | |
839 | ||
840 | % grep FIONREAD /usr/include/*/* | |
841 | /usr/include/asm/ioctls.h:#define FIONREAD 0x541B | |
842 | ||
843 | Or write a small C program using the editor of champions: | |
844 | ||
845 | % cat > fionread.c | |
846 | #include <sys/ioctl.h> | |
847 | main() { | |
848 | printf("%#08x\n", FIONREAD); | |
849 | } | |
850 | ^D | |
851 | % cc -o fionread fionread.c | |
852 | % ./fionread | |
853 | 0x4004667f | |
854 | ||
855 | And then hard code it, leaving porting as an exercise to your successor. | |
856 | ||
857 | $FIONREAD = 0x4004667f; # XXX: opsys dependent | |
858 | ||
859 | $size = pack("L", 0); | |
860 | ioctl(FH, $FIONREAD, $size) or die "Couldn't call ioctl: $!\n"; | |
861 | $size = unpack("L", $size); | |
862 | ||
863 | FIONREAD requires a filehandle connected to a stream, meaning that sockets, | |
864 | pipes, and tty devices work, but I<not> files. | |
865 | ||
866 | =head2 How do I do a C<tail -f> in perl? | |
867 | ||
868 | First try | |
869 | ||
870 | seek(GWFILE, 0, 1); | |
871 | ||
872 | The statement C<seek(GWFILE, 0, 1)> doesn't change the current position, | |
873 | but it does clear the end-of-file condition on the handle, so that the | |
874 | next <GWFILE> makes Perl try again to read something. | |
875 | ||
876 | If that doesn't work (it relies on features of your stdio implementation), | |
877 | then you need something more like this: | |
878 | ||
879 | for (;;) { | |
880 | for ($curpos = tell(GWFILE); <GWFILE>; $curpos = tell(GWFILE)) { | |
881 | # search for some stuff and put it into files | |
882 | } | |
883 | # sleep for a while | |
884 | seek(GWFILE, $curpos, 0); # seek to where we had been | |
885 | } | |
886 | ||
887 | If this still doesn't work, look into the POSIX module. POSIX defines | |
888 | the clearerr() method, which can remove the end of file condition on a | |
889 | filehandle. The method: read until end of file, clearerr(), read some | |
890 | more. Lather, rinse, repeat. | |
891 | ||
892 | There's also a File::Tail module from CPAN. | |
893 | ||
894 | =head2 How do I dup() a filehandle in Perl? | |
895 | ||
896 | If you check L<perlfunc/open>, you'll see that several of the ways | |
897 | to call open() should do the trick. For example: | |
898 | ||
899 | open(LOG, ">>/tmp/logfile"); | |
900 | open(STDERR, ">&LOG"); | |
901 | ||
902 | Or even with a literal numeric descriptor: | |
903 | ||
904 | $fd = $ENV{MHCONTEXTFD}; | |
905 | open(MHCONTEXT, "<&=$fd"); # like fdopen(3S) | |
906 | ||
907 | Note that "<&STDIN" makes a copy, but "<&=STDIN" make | |
908 | an alias. That means if you close an aliased handle, all | |
909 | aliases become inaccessible. This is not true with | |
910 | a copied one. | |
911 | ||
912 | Error checking, as always, has been left as an exercise for the reader. | |
913 | ||
914 | =head2 How do I close a file descriptor by number? | |
915 | ||
916 | This should rarely be necessary, as the Perl close() function is to be | |
917 | used for things that Perl opened itself, even if it was a dup of a | |
918 | numeric descriptor as with MHCONTEXT above. But if you really have | |
919 | to, you may be able to do this: | |
920 | ||
921 | require 'sys/syscall.ph'; | |
922 | $rc = syscall(&SYS_close, $fd + 0); # must force numeric | |
923 | die "can't sysclose $fd: $!" unless $rc == -1; | |
924 | ||
925 | Or, just use the fdopen(3S) feature of open(): | |
926 | ||
927 | { | |
928 | local *F; | |
929 | open F, "<&=$fd" or die "Cannot reopen fd=$fd: $!"; | |
930 | close F; | |
931 | } | |
932 | ||
933 | =head2 Why can't I use "C:\temp\foo" in DOS paths? Why doesn't `C:\temp\foo.exe` work? | |
934 | ||
935 | Whoops! You just put a tab and a formfeed into that filename! | |
936 | Remember that within double quoted strings ("like\this"), the | |
937 | backslash is an escape character. The full list of these is in | |
938 | L<perlop/Quote and Quote-like Operators>. Unsurprisingly, you don't | |
939 | have a file called "c:(tab)emp(formfeed)oo" or | |
940 | "c:(tab)emp(formfeed)oo.exe" on your legacy DOS filesystem. | |
941 | ||
942 | Either single-quote your strings, or (preferably) use forward slashes. | |
943 | Since all DOS and Windows versions since something like MS-DOS 2.0 or so | |
944 | have treated C</> and C<\> the same in a path, you might as well use the | |
945 | one that doesn't clash with Perl--or the POSIX shell, ANSI C and C++, | |
946 | awk, Tcl, Java, or Python, just to mention a few. POSIX paths | |
947 | are more portable, too. | |
948 | ||
949 | =head2 Why doesn't glob("*.*") get all the files? | |
950 | ||
951 | Because even on non-Unix ports, Perl's glob function follows standard | |
952 | Unix globbing semantics. You'll need C<glob("*")> to get all (non-hidden) | |
953 | files. This makes glob() portable even to legacy systems. Your | |
954 | port may include proprietary globbing functions as well. Check its | |
955 | documentation for details. | |
956 | ||
957 | =head2 Why does Perl let me delete read-only files? Why does C<-i> clobber protected files? Isn't this a bug in Perl? | |
958 | ||
959 | This is elaborately and painstakingly described in the | |
960 | F<file-dir-perms> article in the "Far More Than You Ever Wanted To | |
961 | Know" collection in http://www.cpan.org/olddoc/FMTEYEWTK.tgz . | |
962 | ||
963 | The executive summary: learn how your filesystem works. The | |
964 | permissions on a file say what can happen to the data in that file. | |
965 | The permissions on a directory say what can happen to the list of | |
966 | files in that directory. If you delete a file, you're removing its | |
967 | name from the directory (so the operation depends on the permissions | |
968 | of the directory, not of the file). If you try to write to the file, | |
969 | the permissions of the file govern whether you're allowed to. | |
970 | ||
971 | =head2 How do I select a random line from a file? | |
972 | ||
973 | Here's an algorithm from the Camel Book: | |
974 | ||
975 | srand; | |
976 | rand($.) < 1 && ($line = $_) while <>; | |
977 | ||
978 | This has a significant advantage in space over reading the whole | |
979 | file in. A simple proof by induction is available upon | |
980 | request if you doubt the algorithm's correctness. | |
981 | ||
982 | =head2 Why do I get weird spaces when I print an array of lines? | |
983 | ||
984 | Saying | |
985 | ||
986 | print "@lines\n"; | |
987 | ||
988 | joins together the elements of C<@lines> with a space between them. | |
989 | If C<@lines> were C<("little", "fluffy", "clouds")> then the above | |
990 | statement would print | |
991 | ||
992 | little fluffy clouds | |
993 | ||
994 | but if each element of C<@lines> was a line of text, ending a newline | |
995 | character C<("little\n", "fluffy\n", "clouds\n")> then it would print: | |
996 | ||
997 | little | |
998 | fluffy | |
999 | clouds | |
1000 | ||
1001 | If your array contains lines, just print them: | |
1002 | ||
1003 | print @lines; | |
1004 | ||
1005 | =head1 AUTHOR AND COPYRIGHT | |
1006 | ||
1007 | Copyright (c) 1997-2002 Tom Christiansen and Nathan Torkington. | |
1008 | All rights reserved. | |
1009 | ||
1010 | This documentation is free; you can redistribute it and/or modify it | |
1011 | under the same terms as Perl itself. | |
1012 | ||
1013 | Irrespective of its distribution, all code examples here are in the public | |
1014 | domain. You are permitted and encouraged to use this code and any | |
1015 | derivatives thereof in your own programs for fun or for profit as you | |
1016 | see fit. A simple comment in the code giving credit to the FAQ would | |
1017 | be courteous but is not required. |