$data = do { local $/ = undef; <$file> };
[download]

What this line of code does is clear the input record separator, $/, which is a newline character by default and delimits Perl's concept of what a "line" is. By undefining this variable, the first read of this file handle, <$file>, slurps the entire file into the variable. This behaviour is documented in perlvar.

Update

See particle's post in this thread here for an alternate method which also harnesses the magic of @ARGV allowing for the slurping of entire files into either an array or scalar using only a single line of code - For example: [@data|$data] = do { local( $/ ) = wantarray ? $/ : undef; local( @ARGV ) = @_; <> };

perl -le 'print+unpack("N",pack("B32","00000000000000000000000111110111"))'

Is it possible to alter this so every new-line is printed to a new-line?? for some reason this merges all lines together. ;-)

This is not normal behaviour and where we will need to see some code to understand what is happening. Altering the value of the input record separator, $/, in the manner described has no effect on the substance of the data read into the scalar variable.

 

perl -le 'print+unpack("N",pack("B32","00000000000000000000000111111000"))'

Is it possible to alter this so every new-line is printed to a new-line?? for some reason this merges all lines together.

$_ = join("\n", <FILE>);
[download]

Adds a second \n to every line. This may be what you are looking for. Seems a bit odd though.

I have done this kind of thing (with some differences) when doing quick and dirty text->html output. Say you want to put <p> tags when you have blank lines but otherwise leave the text untouched then the folowing code works:

do {local $/ = $/.$/;print join('<p>', <FILE>);};
[download]

Dingus

---

Enter any 47-digit prime number to continue.

#!/usr/bin/perl -w

use strict;

open FILE, "DATA.DAT" or die $!; 

my $scalar;
{
        local $/=undef; # slurp mode on

        $scalar=<FILE>;
}
print $scalar;
[download]

although rob_au and thinker have provided valid responses, i prefer to use a subroutine and stick it in a utility module. besides providing reusability, it does not pollute your namespace with filehandle names. here's a sample from my Utl module:

package Utl;
require 5.006_001;
use strict;
use warnings;

## a library of categorized utilities and functions

our $VERSION = 0.03;

our %slurp = (
    ## slurp a file to a scalar
    ##   pass filename (as scalar)
    ##   returns contents of file (scalar context)
    to_scalar => sub{ local( *ARGV, $/ ); @ARGV = @_; <> },

    ## slurp one or more files to an array
    ##   pass filename(s) (as scalar)
    ##   returns contents of file(s) (list context)
    ##   returns number of lines (scalar context)
    to_array => sub{ local *ARGV; @ARGV = @_; <> },
);

### more utilities follow...
[download]

you'd use it like so:

my $file = $Utl::slurp{to_scalar}->( $filename );

## or for an array...

my @file = $Utl::slurp{to_array}->( $filename );
[download]

use it in good health.

~Particle *accelerates*

use File::Slurp;

my $data = read_file $filename;
[download]