Gestion des fichiers

Ouverture et fermeture d'un ou plusieurs fichiers

open (fic1, "fichier1") ;

# ouvre fichier1, et lui associe l'identifiant fic1

Différents modes d'accès à un fichier sont envisageables avec Perl :

- mode lecture : cf. ci-dessus ; c'est le mode par défaut.
- mode écriture : open (fic1, ">fichier1") ;
- mode ajout : open (fic1, ">>fichier1") ;
- mode lecture + écriture : open (fic1, "+>fichier1") ;
+> permet d'écrire en fin de fichier. Si on veut écrire en début de fichier, utiliser <+.
 

La commande open renvoie une valeur booléenne. La commande est donc utilisable comme condition dans un test pour vérifier que le fichier est bien ouvert.

La fermeture d'un fichier se fait en utilisant son identifiant, par exemple avec close(fic1).

Lecture d'un fichier

Une fois le fichier dont l'identifiant est fic1 ouvert, on peut en lire une ligne avec :
$ligne = <fic1> ;

La lecture de la dernière ligne de ce fichier se fera de la manière suivante :
 

($derniere_ligne) = reverse <fic1>;

# les parenthèses sont nécessaires

On peut également "envoyer" le contenu de la lecture dans un tableau :
 

@tab = <fic1> ;

# chaque ligne de fic1 devient un élément de tab

On peut également lire l'entrée standard avec :
$ligne = <> ;

Ceci permet en outre de lire plusieurs fichiers séquentiellement, fichiers passés en argument du programme Perl. Le tableau spécial @ARGV contient les arguments passés au moment de l'appel du programme. Ainsi, si on lance prog par prog fic1 fic2, @ARGV sera le tableau ("fic1", "fic2").

La fonction eof retourne une valeur non nulle si le dernier fichier d'entrée a été lu en entier, et 0 sinon.

La substitution des variables scalaires est possible dans < >. Ainsi,
$fichier = "fic1";
$ligne = <$fichier> ;
est une séquence équivalente à
$ligne = <fic1> ;
On peut en outre utiliser les modèles Unix de listes de noms de fichiers :
@listefic = <*.pl> ;
permet d'affecter la liste de tous les fichiers .pl à la variable tableau @listefic.

Sauts dans un fichier

La syntaxe de la commande seek est la suivante :
seek (varFic,distance,index);
distance représente le nombre d'octets à sauter. index vaut 0, 1 ou 2 selon que l'on veuille sauter distance octets par rapport au début, à la position courante, ou à la fin du fichier. La position courante est l'emplacement de la ligne suivante à lire. Ainsi,
seek(monFic,0,2); # permet d'aller à la fin du fichier (pour y écrire, par ex.)
seek(monFic,-50,1); # revient 50 octets en arrière

La fonction tell retourne la distance en octets entre le début du fichier et la position courante.

Lecture de caractères

La fonction getc permet de lire un seul carctère d'un fichier d'entrée :
$carac = getc(monFic);

Ecriture dans un fichier

Une fois un fichier ouvert en écriture, on peut y écrire avec :
print fic1 ("toto\n") ;

Erreurs

Afin de mettre fin à un programme, par exemple en cas d'ouverture infructueuse d'un fichier, on peut utiliser la commande die, et diriger les messages (pas forcément d'erreur) vers STDERR :

open (fic, "/usr/bin/toto") || die ("Unable to open toto\n");
print STDERR ("File toto opened successfully\n");

Si toto existe, print affiche sur STDERR le message de confirmation d'ouverture, alors que die interrompt le programme et affiche le message d'erreur si l'ouverture de toto s'est révélée impossible (cf. l'opérateur ||, qui désigne le OU logique). On peut également écrire cette première ligne sous la forme plus complexe :

unless (open(fic,"/usr/bin/toto")) {
    die ("Unable to open toto\n");
}

Opérateurs de vérification de fichier

      

-e fic	# le fichier existe
-r fic	# l'accès en lecture est possible
-w fic	# l'accès en écriture est possible
-x fic	# l'exécution est possible
-z fic	# le fichier existe mais est vide
-s fic	# taille du fichier en octets

Ouverture de canaux

On peut créer un canal entre un fichier de sortie Perl et l'entrée standard d'une autre commande :

open (msg, "| mail titi") ;
print msg ("Coucou") ;
close (msg) ;

Cela enverra un "Coucou" à l'utilisateur titi au moment du close, ou à la fin du programme si le canal n'est pas fermé.
Inversement, si l'on veut traiter le fichier ouvert comme une commande qui redirige des données vers un programme on fait suivre le nom du fichier d'un pipe :

open (CAT, "cat file*|");

Cette ligne exécute la commande cat file*, dont la sortie est considérée comme le fichier dont la variable est CAT.
 

Manipulation de répertoires

Les commandes sont je pense suffisamment explicites :

mkdir(nomrép, permissions);	# création de répertoire (les permissions,comme sous Unix, sont # exprimées par un nombre octal)
chdir(nomrép);	# changement de répertoire courant
opendir(varrép,nomrep);	# "ouverture" du rép. nomrep auquel on associe la variable varrép
closedir(varrép);	# fermeture du rép identifié par varrép

Une fois un répertoire ouvert, on peut accéder à n'importe quel fichier de ce répertoire avec la commande :
readdir(varrép);
 

Format d'impression

Un format se définit de la manière suivante :

format MONFORMAT =
=======
COUCOU
=======
.

La dernière ligne contenant le point ne doit pas être oubliée, c'est elle qui indique la fin de spécification du format.
Lorsque l'on veut afficher un résultat en utilisant un format, il faut au préalable affecter le nom du format à la variable système $~, puis appeler la fonction write :

$~ = "monformat";
write ;
format monformat =
--------
BEUARHHH
--------
.

On peut évidemment indiquer des champs valeurs dans les définitions de formats :

#!/bin/perl
$a = 2;
$b = 3;
$~ = "form";
write;
format form =
========
Nous avons mangé @ bananes et @ pommes.
$a, $b
========
.

permet d'afficher :

========
Nous avons mangé 2 bananes et 3 pommes.
========

Les formats de champ valeur disponibles sont :

@<<< justifié à gauche

@>>> justifié à droite

@||| centré

@##.## format numérique à virgule fixe

@* texte multiligne

Le nombre de <, >, | ou # spécifie le nombre de caractères à afficher à la place du champ valeur. Si le caractère @ est spécifié seul, comme dans l'exemple précédent, le texte n'est pas mis en forme. Le caractère @ lui-même est compris dans le comptage du nombre de caractères du champ valeur. Ainsi, le champ @###.## a une longueur de sept caractères : quatre avant la virgule, et deux après.

Le champ multiligne @* permet de reconnaître les caractères de nouvelle ligne et de traiter l'affichage en conséquence.

La fonction write peut être redirigée vers un autre fichier que la sortie standard avec la séquence de commandes :

select (monFichier);

$~ = "monFormat";

write ;

Le format et le fichier sont associés dans le sens où chaque variable de fichier possède son propre format d'impression.

La commande $ancFic = select(nouvFich) permet de définir nouvFich comme variable de fichier courante tout en affectant le nom de l'ancien fichier à la variable $ancFic, que l'on peut ensuite réutiliser avec select($ancFic).

printf

La commande printf peut être utilisée en Perl comme en C. Les spécificateurs de champ sont les suivants :

%c caractère simple
%d entier en base 10
%e nombre à virgule flottante en notation scientifique
%f nombre à virgule flottante en notation normale (virgule fixe)
%g nombre à virgule flottante en format compact
%s chaîne de caractères
%u entier non signé

La commande printf ("J'ai mangé %d bananes.\n",$nb) permet par exemple d'afficher le nombre $nb de bananes ingurgitées.

Un entier positif après le caractère % indique la largeur de champ minimale. Ainsi, %20s imprime une chaîne (justifiée à droite,à moins de rajouter un - devant la largeur du champ) dans un champ de 20 caractères.