En Perl, ¿cómo puedo leer un archivo completo en una cadena?

Lo haría así:

my $file = "index.html";
my $document = do {
    local $/ = undef;
    open my $fh, "<", $file
        or die "could not open $file: $!";
    <$fh>;
};

Tenga en cuenta el uso de la versión de tres argumentos de open. Es mucho más seguro que las viejas versiones de dos (o uno) argumentos. También tenga en cuenta el uso de un léxico filehandle. Los manejadores de archivos léxicos son más agradables que las antiguas variantes de palabras a pelo, por muchas razones. Estamos aprovechando una de ellas aquí: cierran cuando se salen del alcance.

Con Archivo::Slurp:

use File::Slurp;
my $text = read_file('index.html');

Sí, incluso usted puede usar CPAN.

Todos los mensajes son ligeramente no idiomáticos. El modismo es:

open my $fh, '<', $filename or die "error opening $filename: $!";
my $data = do { local $/; <$fh> };

En su mayoría, no hay necesidad de establecer {/a undef.

De perlfaq5: ¿Cómo puedo leer un archivo entero a la vez?:

Puede usar el módulo File::Slurp para hacerlo en un solo paso.

use File::Slurp;

$all_of_it = read_file($filename); # entire file in scalar
@all_lines = read_file($filename); # one line per element

El enfoque habitual de Perl para procesar todas las líneas en un archivo es hacerlo una línea a la vez:

open (INPUT, $file)     || die "can't open $file: $!";
while (<INPUT>) {
    chomp;
    # do something with $_
    }
close(INPUT)            || die "can't close $file: $!";

Esto es tremendamente más eficiente que leer el archivo completo en la memoria como una matriz de líneas y luego procesarlo un elemento a la vez, lo que a menudo, si no casi siempre, es el enfoque incorrecto. Cada vez que vea a alguien hacer esto:

@lines = <INPUT>;

Usted debe pensar mucho acerca de por qué necesita todo cargado a la vez. Simplemente no es una solución escalable. También puede que le resulte más divertido usar el módulo estándar Tie::File, o los enlaces DB DB_RECNO del módulo DB_File, que le permiten vincular un array a un archivo para que al acceder a un elemento el array realmente acceda a la línea correspondiente en el archivo.

Se puede leer todo el contenido del filehandle en un escalar.

{
local(*INPUT, $/);
open (INPUT, $file)     || die "can't open $file: $!";
$var = <INPUT>;
}

Que desactiva temporalmente su separador de registros, y cerrará automáticamente el archivo al salir del bloque. Si el archivo ya está abierto, simplemente use esto:

$var = do { local $/; <INPUT> };

Para archivos ordinarios también puede usar la función de lectura.

read( INPUT, $var, -s INPUT );

El tercer argumento prueba el tamaño de bytes de los datos en el manejador de archivos de ENTRADA y lee esos muchos bytes en el búfer var var.

Una manera simple es:

while (<FILE>) { $document .= $_ }

Otra forma es cambiar el separador de registros de entrada "$/". Puede hacerlo localmente en un bloque desnudo para evitar cambiar el separador de registros globales.

{
    open(F, "filename");
    local $/ = undef;
    $d = <F>;
}

O bien establecer $/ a undef (ver la respuesta de jrockway) o simplemente concatenar todas las líneas del archivo:

$content = join('', <$fh>);

Se recomienda usar escalares para los manejadores de archivos en cualquier versión de Perl que lo soporte.

Otra forma posible:

open my $fh, '<', "filename";
read $fh, my $string, -s $fh;
close $fh;

Solo obtienes la primera línea del operador del diamante <FILE> porque la estás evaluando en contexto escalar:

$document = <FILE>; 

En el contexto list/array, el operador diamond devolverá todas las líneas del archivo.

@lines = <FILE>;
print @lines;

Lo haría de la manera más simple, para que cualquiera pueda entender lo que sucede, incluso si hay formas más inteligentes:

my $text = "";
while (my $line = <FILE>) {
    $text .= $line;
}

open f, "test.txt"
$file = join '', <f>

<f> - devuelve una matriz de líneas de nuestro archivo (si $/ tiene el valor predeterminado "\n") y luego join '' se pegará esta matriz en.

Esto es más una sugerencia sobre cómo NO hacerlo. Acabo de tener un mal momento para encontrar un error en una aplicación de Perl bastante grande. La mayoría de los módulos tenían sus propios archivos de configuración. Para leer los archivos de configuración como un todo, encontré esta sola línea de Perl en algún lugar de Internet:

# Bad! Don't do that!
my $content = do{local(@ARGV,$/)=$filename;<>};

Reasigna el separador de líneas como se explicó anteriormente. Pero también reasigna la STDIN.

Esto tuvo al menos un efecto secundario que me costó horas encontrar: No se cierra el fichero implícito se maneja correctamente (ya que no llama a close en absoluto).

Por ejemplo, haciendo eso:

use strict;
use warnings;

my $filename = 'some-file.txt';

my $content = do{local(@ARGV,$/)=$filename;<>};
my $content2 = do{local(@ARGV,$/)=$filename;<>};
my $content3 = do{local(@ARGV,$/)=$filename;<>};

print "After reading a file 3 times redirecting to STDIN: $.\n";

open (FILE, "<", $filename) or die $!;

print "After opening a file using dedicated file handle: $.\n";

while (<FILE>) {
    print "read line: $.\n";
}

print "before close: $.\n";
close FILE;
print "after close: $.\n";

Resultados en:

After reading a file 3 times redirecting to STDIN: 3
After opening a file using dedicated file handle: 3
read line: 1
read line: 2
(...)
read line: 46
before close: 46
after close: 0

Lo extraño es que el contador de líneas $. se incrementa por cada archivo en uno. No se reinicia, y no contiene el número de líneas. Y no se restablece a cero al abrir otro archivo hasta que se lea al menos una línea. En mi caso, estaba haciendo algo como esto:

while($. < $skipLines) {<FILE>};

Debido a este problema, la condición era falso porque el contador de línea no se restableció correctamente. No se si esto es un error o simplemente un código equivocado... También llamar a close; oder close STDIN; no ayuda.

Reemplacé este código ilegible usando open, concatenación de cadenas y close. Sin embargo, la solución publicada por Brad Gilbert también funciona, ya que utiliza un controlador de archivo explícito en su lugar.

Las tres líneas al principio pueden ser reemplazadas por:

my $content = do{local $/; open(my $f1, '<', $filename) or die $!; my $tmp1 = <$f1>; close $f1 or die $!; $tmp1};
my $content2 = do{local $/; open(my $f2, '<', $filename) or die $!; my $tmp2 = <$f2>; close $f2 or die $!; $tmp2};
my $content3 = do{local $/; open(my $f3, '<', $filename) or die $!; my $tmp3 = <$f3>; close $f3 or die $!; $tmp3};

Que cierra correctamente el controlador de archivo.

Use

 $/ = undef;

Antes de $document = <FILE>;. $/es el separador de registros de entrada , que es una nueva línea por defecto. Al redefinirlo a undef, usted está diciendo que no hay separador de campos. Esto se llama modo "slurp".

^{Otras soluciones como undef $/ y local $/ (pero no my $/) redeclare $/ y por lo tanto producen el mismo efecto.}

Simplemente podría crear una sub-rutina:

#Get File Contents
sub gfc
{
    open FC, @_[0];
    join '', <FC>;
}

No se si es una buena práctica, pero solía usar esto:

($a=<F>);

Todas estas son buenas respuestas. PERO si te sientes perezoso, y el archivo no es tan grande, y la seguridad no es un problema (sabes que no tienes un nombre de archivo contaminado), entonces puedes pagar:

$x=`cat /tmp/foo`;    # note backticks, qw"cat ..." also works

Puedes usar cat en Linux:

@file1=\`cat /etc/file.txt\`;