Perl Language
Fichier I / O (lecture et écriture de fichiers)

Paramètres

Remarques

Lecture d'un fichier

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

Si vous savez que votre fichier d'entrée est UTF-8, vous pouvez spécifier l'encodage:

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

Une fois la lecture du fichier terminée, le descripteur de fichier doit être fermé:

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

Voir aussi: Lecture d'un fichier dans une variable

Un autre moyen plus rapide de lire un fichier consiste à utiliser File :: Slurper Module. Ceci est utile si vous travaillez avec de nombreux fichiers.

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

Voir aussi: [Lire un fichier avec slurp]

Ecrire dans un fichier

Ce code ouvre un fichier pour l'écriture. Renvoie une erreur si le fichier n'a pas pu être ouvert. Ferme également le fichier à la fin.

#!/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: $!";

Nous avons maintenant un fichier ouvert prêt à être écrit auquel nous accédons via $fh (cette variable s'appelle un descripteur de fichier). Ensuite, nous pouvons diriger la sortie vers ce fichier en utilisant l'opérateur d' print :

# 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: $!";

L'opérateur open a une variable scalaire ( $fh dans ce cas) comme premier paramètre. Comme il est défini dans l'opérateur open , il est traité comme un descripteur de fichier . Le deuxième paramètre ">" (supérieur à) définit que le fichier est ouvert pour écriture. Le dernier paramètre est le chemin du fichier dans lequel écrire les données.

Pour écrire les données dans le fichier, l'opérateur d' print est utilisé avec le descripteur de fichier. Notez que dans l'opérateur d' print , il n'y a pas de virgule entre le descripteur de fichier et l'instruction elle-même, juste un espace.

Ouvrir un fichier FileHandle pour la lecture

Ouverture de fichiers texte ASCII génériques

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

Ouverture de fichiers binaires

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

Ouverture de fichiers texte UTF8

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

Lecture et écriture dans un fichier

Avant de lire et d'écrire des fichiers texte, vous devez savoir quel encodage utiliser. Consultez la documentation Perl Unicode pour plus de détails sur le codage . Nous montrons ici le réglage de UTF-8 comme codage et décodage par défaut pour la fonction open . Cela se fait en utilisant le pragma open haut de votre code (juste après l’ use strict; et use warnings; serait approprié):

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

La fonction open crée un descripteur de fichier utilisé pour lire et / ou écrire dans un fichier. La fonction open a la signature

open(FILEHANDLE, MODE, FILEPATH) et renvoie une valeur fausse si l'opération échoue. La description de l'erreur est ensuite stockée dans $! .

En train de lire

#!/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!";

L'écriture

#!/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!";

Lecture de morceaux

L'ouverture et la lecture de gros fichiers peuvent prendre du temps et des ressources. Si seulement une petite partie du contenu est requise, il peut être judicieux de lire le contenu en morceaux à l’aide de la fonction de read qui a la signature.

read(FILEHANDLE, SCALAR, LENGTH, OFFSET)

FILEHANDLE doit être un handle de fichier ouvert, SCALAR conservera les données lues après l'opération. LENGTH spécifie le nombre de caractères à lire à partir du OFFSET . La fonction renvoie le nombre de caractères lus, 0 si la fin du fichier a été atteinte et undef en cas d'erreur.

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

Lit 16 caractères depuis le début du fichier dans $data .

"utiliser autodie" et vous n'avez pas besoin de vérifier les échecs d'ouverture / fermeture de fichier

autodie vous permet de travailler avec des fichiers sans avoir à vérifier explicitement les échecs d'ouverture / fermeture.

Depuis Perl 5.10.1, le pragma autodie est disponible dans le noyau Perl. Lorsqu'il est utilisé, Perl vérifie automatiquement les erreurs lors de l'ouverture et de la fermeture des fichiers.

Voici un exemple dans lequel toutes les lignes d'un fichier sont lues puis écrites à la fin d'un fichier journal.

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;

En passant, vous devriez toujours vérifier techniquement print instructions print . Beaucoup de gens ne le font pas, mais perl (l'interpréteur Perl) ne le fait pas automatiquement, pas plus autodie .

Rembobiner un descripteur de fichier

Parfois, il est nécessaire de revenir en arrière après avoir lu.

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

Lecture et écriture de fichiers compressés gzip

Ecrire un fichier compressé

Pour écrire un fichier compressé, use le module IO::Compress::Gzip et créez un descripteur de fichier en créant une nouvelle instance de IO::Compress::Gzip pour le fichier de sortie souhaité:

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;

Lecture d'un fichier compressé

Pour lire un fichier compressé, use le module IO::Uncompress::Gunzip , puis créez un descripteur de fichier en créant une nouvelle instance de IO::Uncompress::Gunzip pour le fichier d'entrée:

#!/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;

Définition du codage par défaut pour IO

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

Ce pragma change le mode par défaut de lecture et d'écriture du texte (fichiers, entrée standard, sortie standard et erreur standard) en UTF-8, ce qui correspond généralement à ce que vous souhaitez lors de l'écriture de nouvelles applications.

ASCII est un sous-ensemble de UTF-8, ce qui ne devrait pas poser de problème avec les fichiers ASCII hérités et vous aidera à vous protéger contre la corruption accidentelle de fichiers pouvant survenir lors du traitement de fichiers UTF-8 en ASCII.

Cependant, il est important que vous sachiez quel est l’encodage de vos fichiers et que vous les gériez en conséquence. ( Raisons pour lesquelles nous ne devrions pas ignorer Unicode. ) Pour un traitement plus approfondi d'Unicode, veuillez consulter la rubrique Perl Unicode .