Section courante

A propos

Section administrative du site

Fichiers texte

Les fichiers texte entreposent les données sous forme de lignes de caractères ASCII. Les lignes ne doivent pas nécessairement être de la même longueur. Chaque ligne se termine par un caractère de fin de ligne (retour chariot). Tout éditeur de texte ou traitement de texte lisant les fichiers ASCII peut modifier ces fichiers, y compris l'environnement QuickPascal.

Le Pascal écrit et lit des fichiers texte de manière séquentielle, à peu près de la même manière qu'un lecteur de cassette audio enregistre ou lit une bande magnétique. L'ajout de capacités d'entrée et de sortie (E/S) de fichiers de base à vos programmes vous permet d'entreposer et de récupérer des données à partir de cette «bande» pour une utilisation à long et à court terme.

Cette page explique comment nommer, ouvrir, lire, écrire et fermer un fichier et comment rediriger les informations textuelles entre votre disque, votre écran et votre imprimante. Il répertorie également les procédures standard utilisées pour travailler avec des fichiers texte.

Travailler avec des fichiers texte

Travailler avec des fichiers texte implique de prendre quelques actions simples :

Les sections suivantes abordent ces étapes en détail.

En guise d'introduction générale, regardez l'exemple de programme suivant :

  1. Program filetest;
  2. Var
  3.  datafile:Text;
  4.  i:Integer;
  5.  
  6. BEGIN
  7.  Assign(datafile,'RAN_DATA.DAT');
  8.  Rewrite(datafile);
  9.  For i:=1 to 100 do Begin
  10.   Writeln(datafile,Random(50));
  11.  End;
  12.  Close(datafile);
  13. END.

La suite de cette page se réfère fréquemment à cet exemple.

Déclaration d'une variable de fichier et d'un nom de fichier

Déclarer une variable de fichier signifie dire à QuickPascal comment vous voulez vous référer au fichier depuis le programme. C'est le nom de la variable par lequel le programme connaît le fichier. Vous la déclarez de la même manière que vous déclareriez n'importe quelle autre variable de texte :

  1. Var
  2.  FileVar:Text;

Lorsque vous lisez ou écrivez ultérieurement des informations dans le fichier, vous faites référence au fichier par le nom que vous donnez à FileVar. Par exemple :

  1. Var datafile:Text;

crée une variable de fichier avec le nom datafile.

Le QuickPascal a également besoin de savoir quel nom vous souhaitez attribuer au fichier texte étant enregistré sur le disque. La procédure Assign associe la variable file au nom du fichier disque :

  1. Assign(FileVar, FileName)

Le QuickPascal accepte cette affectation comme signifiant, «Chaque fois que je dis de lire ou d'écrire dans la variable de fichier FileVar, envoyez les informations au fichier disque avec le nom FileName.» Vous pouvez rendre les deux noms similaires, mais gardez à l'esprit que FileName doit suivre les conventions de nommage des fichiers DOS. Par exemple :

  1. Assign(datafile,'RAN_DATA.DAT');

assimile la variable de fichier datafile au fichier disque RAN_DATA.DAT.

Pour plus de polyvalence, vous pouvez utiliser une variable de chaîne de caractères à la place d'une chaîne littérale telle que 'RAN_DATA.DAT'. L'utilisation d'une variable chaîne de caractères permet à votre programme de demander un nom de fichier. Par exemple :

  1. Var
  2.  datafile:Text;
  3.  filename:String;
  4.  
  5. BEGIN
  6.  Write('Saisissez le nom du fichier de données à ouvrir : ');
  7.  ReadLn(filename);
  8.  Assign(datafile,filename);
  9.  Reset(datafile);
  10.  { : }

Ouverture d'un fichier texte

Avec la variable de fichier et le nom de fichier attribués, vous pouvez soit créer (puis ouvrir) un nouveau fichier, soit en ouvrir un existant.

Ouvrir un nouveau fichier texte

La procédure standard Rewrite crée et ouvre un nouveau fichier texte. Il utilise la syntaxe générale :

Rewrite(FileVar)

Le programme exemple au début de cette page crée et ouvre un nouveau fichier texte avec la ligne :

  1. Rewrite(datafile);

Puisque la procédure Assign a associé la variable de fichier datafile au nom de RAN_DATA.DAT, cette instruction Rewrite crée un nouveau fichier sur le disque également appelé RAN_DATA.DAT.

Notez que si un fichier existe déjà avec le même nom. La réécriture détruit l'ancien fichier. Il est donc préférable de n'utiliser que des noms de fichiers dont vous savez qu'ils sont "sûrs" ou de demander à votre programme de demander à l'utilisateur de confirmer le nom sélectionné.

Une fois que vous avez ouvert un nouveau fichier, vous pouvez immédiatement y écrire un nouveau texte.

Ouverture d'un fichier texte existant

Vous pouvez effectuer des opérations de lecture et d'écriture avec un fichier texte existant. Gardez à l'esprit, cependant, qu'essayer d'ouvrir un fichier inexistant provoque une erreur d'exécution "File not found" ou "Fichier introuvable". Une courte procédure vérifiant l'existence du fichier pourrait vous faire gagner du temps.

Pour ouvrir des fichiers pour lire des données, utilisez la procédure de réinitialisation selon la syntaxe suivante :

Reset(FileVar)

Par exemple, pour ouvrir le fichier nommé RAN_DATA.DAT créé par le programme d'exemple de cette page, vous utiliserez :

  1. Reset(datafile);

La procédure Reset ouvre le fichier et déplace le "pointeur de fichier" (un signet interne indiquant au programme où il se trouve dans le fichier) sur le premier caractère du fichier, prêt à commencer la lecture.

Si vous souhaitez ajouter du texte à la fin d'un fichier existant, ouvrez le fichier avec la procédure Append :

Append(FileVar)

Pour ajouter des données au fichier RAN_DATA.DAT, saisissez :

  1. Append(datafile);

Cela ouvre le fichier et définit le pointeur de fichier à la fin du fichier. Le texte se trouvant actuellement dans le fichier reste inchangé.

Une fois que vous avez ouvert un fichier, vous pouvez immédiatement en lire le texte ou y écrire un nouveau texte.

Écrire du texte dans un fichier

Vous écrivez dans un fichier texte de la même manière que vous écrivez à l'écran. Vous utilisez toujours la procédure Write ou Writeln et l'un de ses codes de formatage standard, mais vous spécifiez également la variable de fichier.

Dans l'exemple au début de cette page, la boucle :

  1. For i:=1 TO 100 do Begin
  2.  Writeln(datafile, Random(50));
  3. End;

envoie 100 entiers aléatoires au fichier texte RAN_DATA.DAT spécifié par la variable de fichier datafile.

Vous pouvez tout aussi facilement écrire du texte ou des nombres formatés dans le fichier, mais n'oubliez pas que même les nombres formatés sont entreposés dans le fichier sous forme de texte. Toute forme acceptable de Write ou Writeln peut envoyer des données à un fichier texte.

Lire le texte d'un fichier

Utilisez la procédure Read ou ReadLn pour lire des données à partir d'un fichier texte ouvert, en spécifiant la variable de fichier. Par exemple :

  1. ReadLn(datafile,line_o_text);

lit une ligne de texte du fichier texte associé à la variable datafile dans la chaîne de caractères line_o_text. Read a le même effet mais lit une variable à la fois plutôt qu'une ligne entière.

Dans l'exemple au début de cette page, avec la boucle FOR, le programme crée un fichier nommé RAN_DATA.DAT rempli de 100 nombres aléatoires entre 0 et 50 (certains nombres apparaissent plus d'une fois). Vous pouvez écrire un programme presque identique pour lire les données du fichier en modifiant la boucle en :

  1. For i:=1 to 100 do Begin
  2.  ReadLn(datafile, random_number_string);
  3. End;

La procédure Readln remplace Writeln et vous devez déclarer random_number_string en tant que variable de type STRING. (Vous auriez également besoin d'ouvrir le fichier pour le lire avec Reset plutôt que pour l'écriture.) Pour reconvertir random_number_string en données numériques, vous devez ajouter :

  1. Val(random_number_string,ran_num,errpos)

après la procédure Readln. (Vous devrez également déclarer ran_num et errpos sous forme d'entiers.)

Dans les cas où vous ne connaissez pas la longueur d'un fichier à l'avance, vous pouvez utiliser une boucle vérifiant la fin du fichier avec la fonction Eof. Par exemple, si vous ne connaissiez pas la longueur du fichier ran_data.dat, vous pourriez réécrire la boucle précédente comme suit :

  1. While not Eof(datafile) do Begin
  2.  Readln(datafile, random_number_string);
  3.  Writeln(random_number_string);
  4. End;

La fonction Eof renvoie un résultat Boolean. Il renvoie False lorsque vous lisez le contenu d'un fichier et True après avoir lu la dernière entrée du fichier. La fonction de fin de ligne, Eoln, fonctionne de manière similaire, mais renvoie True lorsque vous atteignez la fin d'une ligne.

Fermeture d'un fichier texte

Vous devez fermer un fichier lorsque vous avez fini de travailler dessus. Tous les fichiers se ferment avec la même instruction :

Close(FileVar)

où FileVar spécifie un fichier ouvert.

Essayer de fermer un fichier n'étant pas ouvert provoque une erreur d'exécution. Cependant, à moins que vous n'utilisiez un certain nombre de variables de fichier portant le même nom, le compilateur détecte généralement les erreurs potentielles en tant que variables indéfinies (souvent causées par des erreurs de frappe) ou des incompatibilités de type (causées en plaçant une variable non textuelle à la place d'une variable de fichier).

Par exemple, essayez de compiler le programme depuis le début de cette page avec la ligne :

  1. Close(datfile); { 'datafile' est mal orthographié }

génère une erreur de compilateur d'identificateur inconnu.

Le QuickPascal ferme automatiquement tous les fichiers texte encore ouverts lorsqu'un programme se termine.

Augmentation de la vitesse d'entrée et de sortie

Le système d'exécution utilise un tampon collectant temporairement le texte pendant les opérations de lecture et d'écriture dans les fichiers texte. Par défaut, le système d'exécution utilise une mémoire tampon de 128 octets.

Des tampons plus grands améliorent la vitesse des programmes gourmands en d'entrée/sortie, mais ont tendance à ne pas affecter les programmes avec des niveaux d'activité d'entrée/sortie modérés ou faibles. Plus la mémoire tampon est grande, plus la vitesse est élevée. Cependant, à moins que vos programmes ne s'enlisent en raison d'opérations d'entrée/sortie en particulier, la taille de la mémoire tampon par défaut suffit généralement. Gardez à l'esprit que si l'augmentation de la taille de la mémoire tampon peut accélérer un programme, elle augmente également la taille du programme.

La procédure standard SetTextBuf permet d'allouer différentes tailles de tampon. Il utilise la syntaxe générale :

SetTextBuf(FileVar, Buffer^[, Size])

où Buffer fait référence à une variable à utiliser comme tampon et Size indique éventuellement la taille du tampon en octets. Vous pouvez déclarer Buffer comme n'importe quel type de variable, mais vous utilisez généralement un tableau de type Char. Par exemple, si vous vouliez augmenter la taille du tampon du programme présenté précédemment, vous pourriez réécrire le début comme suit :

  1. Program filetest;
  2.  
  3. Var
  4.  datafile:Text;
  5.  i:Integer;
  6.  buffer:Array[1..2048] of Char;
  7.  
  8. BEGIN
  9.  Assign(datafile,'RAN_DATA.DAT');
  10.  Rewrite(datafile);
  11.  SetTextBuf(datafile,buffer);
  12.   { : }
  13. END.

Cet appel à SetTextBuf fournit un grand tableau pour l'entreposage intermédiaire. C'est un peu exagéré pour un groupe de 100 entiers aléatoires (basé sur le reste de l'exemple), mais cela fonctionnerait bien pour lire ou écrire de gros fichiers texte.

Avertissement : L'allocation de tampon doit avoir lieu avant ou immédiatement après l'ouverture du fichier texte. La modification de la taille du tampon de fichier après que des opérations d'entrée/sortie ont déjà eu lieu peut entraîner une perte de données.

Redirection de la sortie texte

Le QuickPascal vous permet d'accéder à un certain nombre de périphériques DOS standard (tels qu'une imprimante et l'écran) en spécifiant le périphérique comme nom de fichier de sortie. Par exemple, en réaffectant la variable file, la même instruction WriteLn pourrait envoyer des données texte à un fichier disque, à l'imprimante ou à l'écran.

Les périphériques DOS utilisent des noms prédéfinis. Les deux plus courants sont le nom de l'imprimante, PRN (supposé se connecter au port LPT1), et le nom de l'écran, CON (abréviation de "console"). Les données envoyées à un périphérique sont acheminées vers le port d'ordinateur approprié.

Pour voir comment fonctionne la réaffectation, considérez un programme qui, à la fin d'une session de génération de données particulièrement exténuante, offre à l'utilisateur le choix d'envoyer les données à l'imprimante, à la console ou au fichier. En fonction de la sélection, le programme attribue une variable de fichier au périphérique ou au fichier texte approprié.

Si OutFileVar est la variable de fichier, le choix de l'imprimante conduit à l'affectation :

  1. Assign(OutFileVar, 'PRN');

pour diriger la sortie vers l'imprimante. (Vous pouvez également obtenir le même effet en utilisant l'unité d'imprimante et en remplaçant la variable de fichier par LST. L'imprimante fournit la variable de fichier texte LST déjà ouverte sur le port d'imprimante LPT1.)

De la même manière :

  1. Assign(OutFileVar, 'CON');

et :

  1. Assign(OutFileVar, NewFile);

diriger la sortie vers l'écran et un fichier disque, respectivement. (NewFile doit être déclaré sous forme de chaîne de caractères et doit contenir le nom du nouveau fichier disque.)

La variable de fichier OutFileVar fait désormais référence à l'emplacement de sortie correct, que cette sortie soit l'imprimante, l'écran ou un nouveau fichier texte. Le programme ouvre le périphérique ou le fichier avec :

  1. Rewrite(OutFileVar);

envoie les données au fichier avec :

  1. Writeln(OutFileVar,TextOut);

et ferme le fichier lorsque vous avez terminé avec :

  1. Close(OutFileVar);

Avec un peu de planification, la même section de code de programme peut exécuter trois fonctions différentes : imprimer des données, envoyer à l'écran ou envoyer à un fichier. La seule différence est le nom de fichier attribué à la variable de fichier. Dans l'exemple ci-dessus, une instruction CASE, ou une structure de prise de décision similaire, attribuerait une variable de nom de fichier appropriée en fonction de la sélection de menu de l'utilisateur.

Procédures et fonctions standard pour l'entrée et la sortie

Un certain nombre de procédures et de fonctions standard de QuickPascal s'appliquent à tous les types de fichiers de données - texte, typés et non typés. Le tableau suivant résume les procédures et fonctions disponibles pour tous les types de fichiers :

Routine Objectif
Assign Associe un tampon de fichier à un nom de fichier
Close Ferme le tampon de fichiers
Eof Renvoie l'état de fin de fichier
Erase Supprime un fichier
IOResult Renvoie l'état d'erreur de la dernière entrée/sortie
Read Lit un ou plusieurs éléments d'un fichier
Rename Renomme un fichier
Reset Ouvre un fichier existant
Rewrite Crée et ouvre un nouveau fichier, après avoir fermé et effacé tout fichier portant le même nom
Write Écrit un ou plusieurs éléments dans un fichier

Plusieurs autres procédures et fonctions standard s'appliquent uniquement aux fichiers texte. Ils apparaissent dans le tableau suivant ci-dessous :

Routine Objectif
Append Ouvre un fichier texte existant pour ajouter plus de texte à la fin du fichier
Eoln Renvoie l'état de fin de ligne
Flush Efface le tampon de texte
Readln Lit un ou plusieurs éléments de données, une ligne à la fois
SeekEof Renvoie l'état de fin de fichier, en ignorant les blancs, les tabulations et les marqueurs de fin de ligne
SeekEoln Renvoie l'état de la fin de ligne, en ignorant les blancs et les tabulations
SetTextBuf Attribue un tampon d'entrée/sortie de fichier texte
Writeln Écrit un ou plusieurs éléments de données et ajoute un marqueur de fin de ligne


Dernière mise à jour : Dimanche, le 28 août 2022