In Perl, come posso leggere un intero file in una stringa?

Sto cercando di aprire un file .html come una stringa lunga e grande. Questo è quello che ho:

open(FILE, 'index.html') or die "Can't read file 'filename' [$!]\n";  
$document = <FILE>; 
close (FILE);  
print $document;

che si traduce in:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN

Tuttavia, voglio che il risultato sia simile a:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

In questo modo posso cercare più facilmente l'intero documento.

Inserisci:

 local $/;

prima di leggere dall'handle del file. Vedi Come posso leggere un intero file tutto in una volta? , o

$ perldoc -q "intero file"

Vedere Variabili relative ai filehandle in perldoc perlvare perldoc -f local.

Per inciso, se puoi mettere il tuo script sul server, puoi avere tutti i moduli che vuoi. Vedi Come mantengo la mia directory modulo / libreria? .

Inoltre, Path :: Class :: File ti permette di bere e vomitare .

Percorso :: Piccolo dà ancora più metodi di convenienza, come slurp, slurp_raw,slurp_utf8 così come le loro spewcontroparti.

Lo farei così:

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

Notare l'uso della versione a tre argomenti di open. È molto più sicuro delle vecchie versioni a due (o uno) argomento. Notare anche l'uso di un filehandle lessicale. I filehandle lessicali sono più belli delle vecchie varianti bareword, per molte ragioni. Ne stiamo approfittando qui: si chiudono quando escono dal campo di applicazione.

Con File :: Slurp :

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

Sì, anche tu puoi usare CPAN .

Tutti i post sono leggermente non idiomatici. L'idioma è:

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

Per lo più, non è necessario impostare $ / su undef.

Da perlfaq5: come posso leggere un intero file tutto in una volta? :

Puoi usare il modulo File :: Slurp per farlo in un solo passaggio.

use File::Slurp;

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

Il consueto approccio Perl per elaborare tutte le righe in un file è di farlo una riga alla volta:

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

Questo è tremendamente più efficiente che leggere l'intero file in memoria come un array di righe e poi elaborarlo un elemento alla volta, il che è spesso - se non quasi sempre - l'approccio sbagliato. Ogni volta che vedi qualcuno fare questo:

@lines = <INPUT>;

dovresti pensare a lungo e intensamente al motivo per cui hai bisogno di caricare tutto in una volta. Non è solo una soluzione scalabile. Potresti anche trovare più divertente usare il modulo standard Tie :: File, o le associazioni $ DB_RECNO del modulo DB_File, che ti consentono di legare un array a un file in modo che accedendo a un elemento l'array acceda effettivamente alla riga corrispondente nel file .

Puoi leggere l'intero contenuto del filehandle in uno scalare.

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

Questo annulla temporaneamente la definizione del separatore di record e chiude automaticamente il file all'uscita dal blocco. Se il file è già aperto, usa questo:

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

Per i file ordinari puoi anche usare la funzione di lettura.

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

Il terzo argomento verifica la dimensione in byte dei dati sul filehandle INPUT e legge altrettanti byte nel buffer $ var.

Un modo semplice è:

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

Un altro modo è modificare il separatore del record di input "$ /". Puoi farlo localmente in un blocco nudo per evitare di cambiare il separatore di record globale.

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

O impostato $/su undef(vedi la risposta di jrockway) o concatena semplicemente tutte le righe del file:

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

Si consiglia di utilizzare gli scalari per i filehandle su qualsiasi versione di Perl che lo supporti.

Un altro modo possibile:

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

Ricevi solo la prima riga dall'operatore diamante <FILE>perché la stai valutando in un contesto scalare:

$document = <FILE>; 

Nel contesto elenco / matrice, l'operatore rombo restituirà tutte le righe del file.

@lines = <FILE>;
print @lines;

Lo farei nel modo più semplice, così chiunque può capire cosa succede, anche se ci sono modi più intelligenti:

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

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

<f>- restituisce un array di righe dal nostro file (se $/ha il valore predefinito "\n") e poi join ''inserirà questo array in.

Questo è più un suggerimento su come NON farlo. Ho appena avuto problemi a trovare un bug in un'applicazione Perl piuttosto grande. La maggior parte dei moduli aveva i propri file di configurazione. Per leggere i file di configurazione nel loro insieme, ho trovato questa singola riga di Perl da qualche parte su Internet:

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

Riassegna il separatore di riga come spiegato prima. Ma riassegna anche STDIN.

Questo ha avuto almeno un effetto collaterale che mi è costato ore da trovare: non chiude correttamente l'handle del file implicito (poiché non chiama closeaffatto).

Ad esempio, in questo modo:

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";

risultati in:

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

La cosa strana è che il contatore di riga $.viene aumentato di uno per ogni file. Non è ripristinato e non contiene il numero di righe. E non viene azzerato quando si apre un altro file fino a quando non viene letta almeno una riga. Nel mio caso, stavo facendo qualcosa del genere:

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

A causa di questo problema, la condizione era falsa perché il contatore di riga non è stato reimpostato correttamente. Non so se sia un bug o semplicemente un codice sbagliato ... Anche chiamare close;oder close STDIN;non aiuta.

Ho sostituito questo codice illeggibile usando open, concatenazione di stringhe e close. Tuttavia, la soluzione pubblicata da Brad Gilbert funziona anche poiché utilizza invece un handle di file esplicito.

Le tre righe all'inizio possono essere sostituite da:

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};

che chiude correttamente l'handle del file.

Uso

 $/ = undef;

prima $document = <FILE>;. $/è il separatore del record di input , che per impostazione predefinita è una nuova riga. Ridefinendolo in undef, stai dicendo che non esiste un separatore di campo. Questa è chiamata modalità "slurp".

^{Altre soluzioni come undef $/e local $/(ma non my $/) ridichiarano $ / e quindi producono lo stesso effetto.}

Potresti semplicemente creare una sub-routine:

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

Non so se sia una buona pratica, ma usavo questo:

($a=<F>);

Queste sono tutte buone risposte. MA se ti senti pigro e il file non è così grande e la sicurezza non è un problema (sai di non avere un nome file contaminato), puoi sborsare:

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

Puoi usare cat in Linux:

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