Joining every line is less efficient, as you wind up searching for newlines to break into lines, allocating an array, filling it, joining it and assigning to a scalar.

The standard approach turns off the newline searching and just reads it to a scalar in a single shot.

See the discussion in the documentation for File::Slurp.

The reason your second block of code isn't used more is because it is much slower. On small amounts of data, you won't notice, but on larger ones you will. Why?

In the top block of code, perl knows to just read, as fast as reasonable, the entire contents of a file and store it to a variable.

In the lower block of code, it must read one line at a time (which takes longer, partly because there must be a check for line endings). Then, it must join those lines into a string before returning. That's a lot of extra steps.

Actually, your "standard" way of slurping is less than ideal as well, since you are copying the string when your function returns. Why not:

my $content;
{
   local $/ = undef;
   open my $fh, $_[0] or die "Can't open $_[0]: $!";
   $content = <$fh>;
}
[download]

Or, if it really must be abstracted into a sub, pass around a reference?

sub slurp {
   local $/ = undef;
   open my $fh, $_[0] or die "Can't open $_[0]: $!";
   my $slurp = <$fh>;
   return \$slurp;
}
my $content = slurp('filename');
print $$content;
[download]

Of course, you could avoid all this re-inventing of the wheel and just use Slurp:

use Slurp;
my $content = slurp('filename');
[download]

I don't know if your way is "standard" or not, but I've done it like so on occasion:

my $content = do { local(@ARGV,$/) = $filename; <> };
[download]

Anyway, why go through all the trouble of reading line by line and joining all of the lines together when you can just read the entire file into a scalar without all of the extra processing?

Don’t use two-argument open. It’s dangerous.

And if you do, at least don’t omit the mode as well. That’s doubly dangerous.

Otherwise, there is opportunity for someone to do mischief, should any user input ever get close to your $filename. Stay away. Be explicit. Use three-argument open and always fasten your seatbelt.

As far as slurping is concerned, as others have mentioned, you want to explicitly undefine $/, so that Perl won’t waste effort splitting the input into lines, only to then waste more effort gluing them back together. I tend to do this using a do {} block, much like those which tinita posted, because I rarely need to slurp files in more than one place in my code.

Makeshifts last the longest.

use v6;

my $content = slurp $file;
[download]