Perl Language
Datei-E / A (Lesen und Schreiben von Dateien)

Parameter

Bemerkungen

Lesen aus einer Datei

my $filename = '/path/to/file';

open my $fh, '<', $filename or die "Failed to open file: $filename"; 
    
# You can then either read the file one line at a time...
while(chomp(my $line = <$fh>)) {
    print $line . "\n";
}

# ...or read whole file into an array in one go
chomp(my @fileArray = <$fh>); 

Wenn Sie wissen, dass Ihre Eingabedatei UTF-8 ist, können Sie die Kodierung angeben:

open my $fh, '<:encoding(utf8)', $filename or die "Failed to open file: $filename";

Nach dem Lesen aus der Datei sollte das Dateihandle geschlossen werden:

close $fh or warn "close failed: $!";

Siehe auch: Lesen einer Datei in eine Variable

Eine andere und schnellere Methode zum Lesen einer Datei ist die Verwendung von File :: Slurper Module. Dies ist nützlich, wenn Sie mit vielen Dateien arbeiten.

use File::Slurper;
my $file = read_text("path/to/file"); # utf8 without CRLF transforms by default
print $file; #Contains the file body

Siehe auch: [Lesen einer Datei mit Slurp]

In eine Datei schreiben

Dieser Code öffnet eine Datei zum Schreiben. Gibt einen Fehler zurück, wenn die Datei nicht geöffnet werden konnte. Schließt auch die Datei am Ende.

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

# Open "output.txt" for writing (">") and from now on, refer to it as the variable $fh.
open(my $fh, ">", "output.txt")
# In case the action failed, print error message and quit.
or die "Can't open > output.txt: $!";

Nun haben wir eine offene Datei, die zum Schreiben bereit ist, auf die wir über $fh zugreifen (diese Variable wird als Dateihandle bezeichnet ). Als Nächstes können Sie die Ausgabe mithilfe des print in diese Datei leiten:

# Print "Hello" to $fh ("output.txt").
print $fh "Hello";
# Don't forget to close the file once we're done!
close $fh or warn "Close failed: $!";

Der open Operator hat als ersten Parameter eine skalare Variable (in diesem Fall $fh ). Da es im open Operator definiert ist, wird es als Dateihandle behandelt. Der zweite Parameter ">" (größer als) legt fest, dass die Datei zum Schreiben geöffnet wird. Der letzte Parameter ist der Pfad der Datei, in die die Daten geschrieben werden sollen.

Um die Daten in die Datei zu schreiben, der print wird Bediener mit dem Dateihandle verwendet zusammen. Beachten Sie, dass in dem print Operator gibt es kein Komma zwischen dem Dateihandle und der Aussage selbst, sondern nur Leerzeichen.

Ein FileHandle zum Lesen öffnen

Generische ASCII-Textdateien öffnen

open my $filehandle, '<', $name_of_file or die "Can't open $name_of_file, $!";

Binärdateien öffnen

open my $filehandle, '<:raw', 'path/to/file' or die "Can't open $name_of_file, $!";

UTF8-Textdateien öffnen

open my $filehandle, '<:raw:encoding(utf-8)', 'path/to/file' 
   or die "Can't open $name_of_file, $!";

Lesen und Schreiben in eine Datei

Bevor Sie Textdateien lesen und schreiben, sollten Sie wissen, welche Kodierung verwendet werden soll. Weitere Informationen zur Kodierung finden Sie in der Perl Unicode-Dokumentation . Hier zeigen wir die Einstellung von UTF-8 als Standardcodierung und -decodierung für die Funktion open . Verwenden Sie dazu das open Pragma oben in Ihrem Code (direkt nach der use strict; und use warnings; wäre angebracht):

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); 

Die open Funktion erstellt ein Dateihandle, das zum Lesen und / oder Schreiben in eine Datei verwendet wird. Die open Funktion hat die Signatur

open(FILEHANDLE, MODE, FILEPATH) und gibt einen falschen Wert zurück, wenn die Operation fehlschlägt. Die Fehlerbeschreibung wird dann in $! gespeichert $! .

lesen

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '<', $file_path) or die "Could not open file! $!";

while(my $row = <$file_handle>) {
    print chomp($row), "\n";
}

close $file_handle 
      or warn "Close failed!";

Schreiben

#!/usr/bin/perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

my $file_path = "/path/to/file";
open(my $file_handle, '>', $file_path) or die "Could not open file! $!";

print $file_handle "Writing to a file";

close $file_handle 
      or warn "Close failed!";

Brocken lesen

Das Öffnen und Lesen großer Dateien kann einige Zeit und Ressourcen in Anspruch nehmen. Wenn nur ein kleiner Teil des Inhalts erforderlich ist, empfiehlt es sich, den Inhalt in Abschnitten mithilfe der read , die die Signatur enthält, zu read

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

FILEHANDLE muss ein geöffneter Datei-Handle sein, SCALAR hält die gelesenen Daten nach der Operation. LENGTH gibt die Anzahl der zu lesenden Zeichen ab OFFSET . Die Funktion gibt die Anzahl der gelesenen Zeichen zurück, 0 wenn das Ende der Datei erreicht wurde und im Fehlerfall undef .

read($file_handle, $data, 16, 0); 

Liest 16 Zeichen vom Anfang der Datei in $data .

"autodie verwenden", und Sie müssen die Fehler beim Öffnen / Schließen der Datei nicht überprüfen

autodie können Sie mit Dateien arbeiten, ohne explizit nach Fehlern beim Öffnen / Schließen zu suchen.

Seit Perl 5.10.1 ist das autodie Pragma in Core-Perl verfügbar. Wenn verwendet, sucht Perl beim Öffnen und Schließen von Dateien automatisch nach Fehlern.

Hier ist ein Beispiel, in dem alle Zeilen einer Datei gelesen und dann an das Ende einer Protokolldatei geschrieben werden.

use 5.010;    # 5.010 and later enable "say", which prints arguments, then a newline
use strict;   # require declaring variables (avoid silent errors due to typos)
use warnings; # enable helpful syntax-related warnings
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding
use autodie;  # Automatically handle errors in opening and closing files

open(my $fh_in, '<', "input.txt"); # check for failure is automatic

# open a file for appending (i.e. using ">>")
open( my $fh_log, '>>', "output.log"); # check for failure is automatic

while (my $line = readline $fh_in) # also works: while (my $line = <$fh_in>)
{
     # remove newline
     chomp $line;

     # write to log file
     say $fh_log $line or die "failed to print '$line'"; # autodie doesn't check print
}

# Close the file handles (check for failure is automatic)
close $fh_in;
close $fh_log;

By the way, sollten Sie technisch immer überprüfen , print Aussagen. Viele Leute tun dies nicht, aber perl (der Perl-Interpreter) tut dies nicht automatisch und auch nicht autodie .

Einen Dateihandle zurückspulen

Manchmal ist es notwendig, nach dem Lesen einen Rücklauf durchzuführen.

# identify current position in file, in case the first line isn't a comment
my $current_pos = tell; 

while (my $line = readline $fh)
{
    if ($line =~ /$START_OF_COMMENT_LINE/)
    {
        push @names, get_name_from_comment($line);
    }
    else {
        last; # break out of the while loop
    }
    $current_pos = tell; # keep track of current position, in case we need to rewind the next line read
}

# Step back a line so that it can be processed later as the first data line
seek $fh, $current_pos, 0;

Lesen und Schreiben von gzip-komprimierten Dateien

Eine komprimierte Datei schreiben

Um eine gzippte Datei zu schreiben, use das Modul IO::Compress::Gzip und erstellen Sie ein Dateihandle, indem Sie eine neue Instanz von IO::Compress::Gzip für die gewünschte Ausgabedatei erstellen:

use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Compress::Gzip;

my $fh_out = IO::Compress::Gzip->new("hello.txt.gz");

print $fh_out "Hello World!\n";

close $fh_out;

use IO::Compress::Gzip;

Lesen aus einer komprimierten Datei

Um aus einer gzippierten Datei zu lesen, use das Modul IO::Uncompress::Gunzip und erstellen dann ein Dateihandle, indem Sie eine neue Instanz von IO::Uncompress::Gunzip für die Eingabedatei erstellen:

#!/bin/env perl
use strict;
use warnings;
use open qw( :encoding(UTF-8) :std ); # Make UTF-8 default encoding

use IO::Uncompress::Gunzip;

my $fh_in = IO::Uncompress::Gunzip->new("hello.txt.gz");

my $line = readline $fh_in;

print $line;

Festlegen der Standardcodierung für E / A

# encode/decode UTF-8 for files and standard input/output
use open qw( :encoding(UTF-8) :std ); 

Dieses pragma ändert den Standardmodus für das Lesen und Schreiben von Text (Dateien, Standardeingabe, Standardausgabe und Standardfehler) in UTF-8, was normalerweise beim Schreiben neuer Anwendungen gewünscht wird.

ASCII ist eine Untergruppe von UTF-8. Es wird daher nicht erwartet, dass dies Probleme mit älteren ASCII-Dateien verursacht. Sie schützt Sie vor versehentlichem Dateibeschädigung, wenn UTF-8-Dateien als ASCII behandelt werden.

Es ist jedoch wichtig, dass Sie wissen, wie die Kodierung Ihrer Dateien ist, und dass Sie entsprechend damit umgehen. ( Gründe, aus denen wir Unicode nicht ignorieren sollten. ) Weitere Informationen zur Behandlung von Unicode finden Sie im Perl-Unicode-Thema .