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