Are there reasons to ever use the two-argument form of open(...) in Perl?

Question

Are there any reasons to ever use the two-argument form of open(...) in Perl rather than the three-or-more-argument versions?

The only reason I can come up with is the obvious observation that the two-argument form is shorter. But assuming that verbosity is not an issue, are there any other reasons that would make you choose the two-argument form of open(...)?

Answer 1

I'm guessing you mean open(FH, '<filename.txt') as opposed to open(FH, '<', 'filename.txt') ?

I think it's just a matter of preference. I always use the former out of habit.

Answer 2

When you are combining a string or using a variable, it can be rather unclear whether '<' or '>' etc is in already. In such cases, I personally prefer readability, which means, I use the longer form:

open($FILE, '>', $varfn);

When you simply use a constant, I prefer the ease-of-typing (and, actually, consider the short version better readable anyway, or at least even to the long version).

open($FILE, '>somefile.xxx');

Answer 3

If you're opening from a pipe, the three argument form isn't really helpful. Getting the equivalent of the three argument form involves doing a safe pipe open (open(FILE, '|-')) and then executing the program.

So for simple pipe opens (e.g. open(FILE, 'ps ax |')), the two argument syntax is much more compact.

Answer 4

I think William's post pretty much hits it. Otherwise, the three-argument form is going to be more clear, as well as safer.

See also:

• http://stackoverflow.com/questions/318789/whats-the-best-way-to-open-and-read-a-file-in-perl
• http://stackoverflow.com/questions/1479741/why-is-three-argument-open-calls-with-lexical-filehandles-a-perl-best-practice

Answer 5

Another small difference : the two argument form trim spaces

$foo = " fic";
open(MH, ">$foo");
print MH "toto\n";

Writes in a file named fic

On the other hand

$foo = " fic";
open(MH, ">", $foo);
print MH "toto\n";

Will write in a file whose name begin with a space.

For short admin scripts with user input (or configuration file input), not having to bother with such details as trimming filenames is nice.

Answer 6

The two argument form of open was the only form supported by some old versions of perl.

Answer 7

One- and two-arg open applies any default layers specified with the -C switch or open pragma. Three-arg open does not. In my opinion, this functional difference is the strongest reason to choose one or the other (and the choice will vary depending what you are opening). Which is easiest or most descriptive or "safest" (you can safely use two-arg open with arbitrary filenames, it's just not as convenient) take a back seat in module code; in script code you have more discretion to choose whether you will support default layers or not.

Also, one-arg open is needed for Damian Conway's file slurp operator

$_ = "filename";
$contents = readline!open(!((*{!$_},$/)=\$_));

Answer 8

One reason to use the two-argument version of open is if you want to open something which might be a pipe, or a file. If you have one function

sub strange
{
     my ($file) = @_;
     open my $input, $file or die $!;
}

then you want to call this either with a filename like "file":

strange ("file");

or a pipe like "zcat file.gz |"

strange ("zcat file.gz |");

depending on the situation of the file you find, then the two-argument version may be used. You will actually see the above construction in "legacy" Perl. However, the most sensible thing might be to open the filehandle appropriately and send the filehandle to the function rather than using the file name like this.

Answer 9

Imagine you are writing a utility that accepts an input file name. People with reasonable Unix experience are used to substituting - for STDIN. Perl handles that automatically only when the magical form is used where the mode characters and file name are one string, else you have to handle this and similar special cases yourself. This is a somewhat common gotcha, I am surprised no one has posted that yet. Proof:

use IO::File qw();
my $user_supplied_file_name = '-';

IO::File->new($user_supplied_file_name, 'r') or warn "IO::File/non-magical mode - $!\n";
IO::File->new("<$user_supplied_file_name")   or warn "IO::File/magical mode - $!\n";
open my $fh1, '<', $user_supplied_file_name  or warn "non-magical open - $!\n";
open my $fh2, "<$user_supplied_file_name"    or warn "magical open - $!\n";

__DATA__
IO::File/non-magical mode - No such file or directory
non-magical open - No such file or directory

Vote me up, I can use the rep points. ☻