Les 15. Werken met bestanden

In deze les gaan we kijken naar heel belangrijk onderwerp bij programmeren - werken met bestanden.
In vrijwel elk programma moet je bestanden kopiëren, openen, wijzigen, opslaan en soms verwijderen.

Zoals u weet, hebben bestanden verschillende formaten en op hen van toepassing zijn diverse programma's voor verwerking. Bijvoorbeeld BMP-afbeeldingsbestanden, tekst TXT-bestanden enz. De bestanden hebben verschillende namen en een specifieke extensie, namelijk MS-DOS-omgeving maximaal drie karakters. Als het bestand een RAR-extensie heeft, wordt de gebruiker en besturingssysteem weet dat dit een archiveringshulpmiddel is, en windowsw gebruikt de tools die zijn gespecificeerd in speciale sectie register

Bestanden kopiëren

De CopyFile-functie wordt gebruikt om bestanden te kopiëren. Het formaat is als volgt:

KopieerBestand(Bronbestand, Schrijfbestand, Overschrijf_vlag);

waar: Bronbestand – volledige pad en de naam van het bestand dat wordt gekopieerd;

Write_file – volledig pad en naam van het bestand waarnaar het bronbestand wordt gekopieerd;

Overwrite_flag – of het bestand wel of niet zal worden overschreven als het al bestaat (true - dat zal niet zo zijn, false - het zal worden overschreven).

CopyFile is een functie die een vlag retourneert, ongeacht of de kopieerbewerking succesvol was of niet.

Bijvoorbeeld de volgende regel:

indien niet CopyFile("c:\command.com","c:\1.com",true) dan ShowMessage("Kopieerfout");

kopieert het command.com-bestand alleen naar het 1.com-bestand als dit laatste niet bestaat, anders wordt een kopieerfoutmelding weergegeven.

Bestanden verplaatsen

De MoveFile-functie wordt gebruikt om bestanden te verplaatsen. Zij heeft volgende formaat:

MoveFile(Bronbestand, Schrijfbestand);

De parameters zijn vergelijkbaar met de bovenstaande opdracht, behalve de afwezigheid van de herschrijfvlag.

zo niet MoveFile("c:\1.com","c:\2.com") dan ShowMessage("Verplaatsingsfout");

Bestanden hernoemen

RenameFile-functie

zo niet RenameFile("c:\2.com","c:\3.com"), dan ShowMessage("Hernoemingsfout");

Alle bovenstaande opdrachten hebben een begin- en definitieve bestand is van het type PChar. Dit tekenreekstype nul-beëindigd. Mogelijk hebt u al eerder van dit tekenreeksgegevensformaat gehoord. Je kunt heel goed een string in zo'n variabele plaatsen. De grootte ervan wordt beperkt door de aanwezigheid van een null-byte aan het einde. Theoretisch kan zo'n variabele een oneindige grootte hebben. In de praktijk wordt dit beperkt door de grootte van het toegewezen geheugen voor het programma (2 GB).

Normaal converteren tekenreeksvariabele, typ Tekenreeks in PChar wordt geproduceerd door de functie:

PChar(String_variabele).

Tegelijkertijd voor teams bestandsbewerkingen aaneenschakeling van strings is mogelijk. Bijvoorbeeld:

procedure TForm1.Button1Click(Afzender: TObject);

Var InDir,UitDir:String; // declaratie van stringvariabelen

beginnen

InDir:="c:\1\"; // map bronbestanden

UitDir:="c:\2\"; // map met bestanden die moeten worden geschreven

CopyFile(PChar(InDir+"1.txt"),PChar(OutDir+"1.txt"),false);

CopyFile(PChar(InDir+"2.txt"),PChar(OutDir+"2.txt"),false);

einde;

Hier hebben we de bewerking van het aaneenschakelen van twee stringvariabelen.

Het resultaat van deze procedure is het kopiëren van de bestanden c:\1\1.txt en c:\1\2.txt naar de map c:\2. De bestanden worden onder dezelfde namen gekopieerd.

Bestanden verwijderen

Functie Bestand verwijderen

zo niet DeleteFile("c:\3.com") dan ShowMessage("Verwijder fout");

Werken met tekstbestanden. Lezen uit een tekstbestand

In eerdere lessen hebben we in de Memo-component het proces van het laden en schrijven van een tekstbestand als volgt uitgevoerd:

Memo1.Lines.SaveToFile(Bestandsnaam);

// redden

Dit alles is te danken aan de eigenschap Lines, waarin lijnen worden opgeslagen.
Het volgende voorbeeld van het verwerken van een tekstbestand lijkt sterk op dat in Pascal. Deskundige mensen

kan het verschil voelen, aangezien er enkele verschillen zijn.

procedureTForm1.Button1Click(Afzender: TObject);

Varf:Tekstbestand; // bestandsvariabele declaratie st: Snaar

beginnen

; // tekenreeksvariabele

AssignFile(f,"c:\1.txt"); // koppelt de bestandsnaam aan een bestandsvariabele

($I-) // schakel I/O-foutcontrole uit

Opnieuw instellen(f); // open bestand om te lezen

($I+) // schakel I/O-foutcontrole in<>0 alsIOResultaat Dan // als dat zo is openingsfout

beginnen

, Dat

ShowMessage("Fout bij openen bestand C:\1.TXT");

Uitgang; // verlaat de procedure als er een fout optreedt bij het openen van een bestand;

einde Terwijl niet EOF(f) Doen // nog niet einde van bestand

beginnen

doe een lus:

Uitgang; // verlaat de procedure als er een fout optreedt bij het openen van een bestand;

Toon bericht(st); // voer een tekenreeks uit naar de gebruiker

einde;

Bestand sluiten(f); // sluit het bestand

Laat me commentaar geven op enkele regels van dit voorbeeld. De opdracht AssignFile bindt een tekenreeks van een bestandspad aan een bestandsvariabele. Alle verdere handelingen met de bestandsvariabele worden automatisch uitgevoerd met opgegeven bestand

($I-) en ($I+) zijn instructies aan de compiler om I/O-foutcontrole op dit punt respectievelijk uit en in te schakelen. In dit geval, als een mislukte poging om het bestand c:\1.txt te openen (het bestand ontbreekt of staat open voor schrijven door een ander programma), zal ons programma geen noodfout genereren en zal het doorgaan met het uitvoeren van deze procedure. Deze eigenschap is handig voor het afhandelen van alles mogelijke gevallen

bij de werking van het programma.

IOResult is een variabele die de foutcode van de laatste I/O-bewerking opslaat. Als deze nul is, is de laatste bewerking met succes voltooid.

EOF(Bestand) – een functie die het einde-van-bestand-teken retourneert. Die. het laat zien of het einde van het geopende bestand is bereikt of niet.

ReadLn(File, Variable) – procedure voor het lezen van een variabele uit een bestand. In tegenstelling tot het Read-commando leest het een regel die eindigt met een newline-teken onder de codes 13 en 10 (Enter-toets).

CloseFile(File) – procedure voor het sluiten van een eerder geopend bestand.

Werken met tekstbestanden. Schrijven naar een tekstbestand

Laten we eens kijken naar een voorbeeld:

procedure TForm1.Button1Click(Afzender: TObject);

Var f:Tekstbestand; // verwijzing naar tekstbestand

AssignFile(f,"c:\1.txt");

// koppelt de naam aan een variabele<>0 Voeg toe(f);// open bestand om toe te voegen

als IOResult Dan //

// koppelt de naam aan een variabele<>als er een fout optreedt bij het openen (er is bijvoorbeeld geen bestand)

Herschrijf(f);

// creëren

nieuw bestand

0 en vervolgens // fout bij het maken van bestanden

ShowMessage("Fout bij aanmaken van bestand C:\1.TXT");

WriteLn(f,"Hallo");

// schrijf naar een bestand een string met nieuweregeltekens

Bestand sluiten(f);// sluit het bestand

De Append-procedure opent een bestand om te schrijven en stelt de schrijfaanwijzer in op het einde van het bestand, d.w.z. alle regels die aan het bestand worden toegevoegd, worden naar het einde van het bestand geschreven. In ons geval staat 1.txt helemaal aan het begin van het bestand mogelijk niet op schijf, dus de opdracht om het bestand te openen om het toe te voegen zal een fout veroorzaken. In dit geval wordt onze eigen foutcontrole geactiveerd en wordt de opdracht voor het maken van bestanden uitgevoerd. Niet-tekstuele gegevens uit een bestand schrijven en lezen Laten we eens kijken naar een voorbeeld waarin een programma bij het afsluiten de grootte en positie van het venster op het scherm opslaat in een bestand en bij daaropvolgende start de toestand herstelt die het had bij het afsluiten. Het programma bestaat uit twee procedures OnShow en OnClose voor het Form1-venster van het programma. procedure

TForm1.FormShow(Afzender: TObject);

beginnen

Var

F:

bestand

van

Geheel getal; // bestandsvariabele, typ geheel getal I: geheel getal; // gehele variabele<>0 alsIOResultaat AssignFile(f,"pos.ini");

($I-)

Opnieuw instellen(f);

Form1.Links:=i; // linker raampositie

Opnieuw instellen(f);

Vorm1.Breedte:=i; // vensterbreedte

Opnieuw instellen(f);

Vorm1.Hoogte:=i; // raamhoogte

Bestand sluiten(f);

Uitgang; // verlaat de procedure als er een fout optreedt bij het openen van een bestand;

Bestand sluiten(f); TForm1.FormClose(Afzender: TObject; var Actie: TSluitActie);

De Append-procedure opent een bestand om te schrijven en stelt de schrijfaanwijzer in op het einde van het bestand, d.w.z. alle regels die aan het bestand worden toegevoegd, worden naar het einde van het bestand geschreven. In ons geval staat 1.txt helemaal aan het begin van het bestand mogelijk niet op schijf, dus de opdracht om het bestand te openen om het toe te voegen zal een fout veroorzaken. In dit geval wordt onze eigen foutcontrole geactiveerd en wordt de opdracht voor het maken van bestanden uitgevoerd. Niet-tekstuele gegevens uit een bestand schrijven en lezen Laten we eens kijken naar een voorbeeld waarin een programma bij het afsluiten de grootte en positie van het venster op het scherm opslaat in een bestand en bij daaropvolgende start de toestand herstelt die het had bij het afsluiten. Het programma bestaat uit twee procedures OnShow en OnClose voor het Form1-venster van het programma. Geheel getal;

Ondanks het feit dat er in Delphi verschillende methoden zijn waarmee u met bestanden kunt communiceren, vereist de besturingstechnologie het naleven van een bepaalde volgorde van acties:

1. Het bestand moet geopend zijn. Andere applicaties mogen de werking van het bestand niet belemmeren; het systeem houdt hier nauwlettend toezicht op. Tegelijkertijd bepaalt het systeem voor welke doeleinden het bestand wordt geopend. Hier zijn verschillende mogelijkheden: lezen of wijzigingen aanbrengen.

Nadat een document is aangemaakt of geopend, ontvangt het systeem een ​​speciale identificatie, die in alle daaropvolgende verwerkingsprocedures als verwijzing naar dit bestand zal worden gebruikt.

3. Na alles noodzakelijke acties worden uitgevoerd en het bestand wordt geschreven, het document wordt gesloten. Vanaf dit moment is het volledig zonder beperkingen beschikbaar voor andere toepassingen. Het is vermeldenswaard dat het sluiten van het bestand garandeert dat alle aangebrachte wijzigingen worden opgeslagen. Dus, toegang tot Delphi-bestand vereiste gegevens met succes voltooid.

Als deze taak vrij ingewikkeld lijkt, dan kun je hulp zoeken bij professionals die, naast Delphi, alles weten wat nodig is over Linux-beheer.

Schrijven naar een Delphi-tekstbestand

In Delphi wordt een bestand weergegeven als een reeks gegevens van hetzelfde type. Met andere woorden: het is genoeg grote reeks, waarvan de omvang vrijwel onbeperkt is. Om het schrijven naar een Delphi-tekstbestand gemakkelijker te maken, wordt elk document weergegeven als een bestandsvariabele.

Om mee te werken tekstdocumenten het type TextFile wordt gebruikt, dat als volgt is geschreven:

Var-variabele: Type TextFile;
Gebruik de procedure om toegang te krijgen tot het bestand Bestand toewijzen(). Zodra toegang tot het bestand is verkregen, kan het worden geopend met behulp van de procedures Resetten, herschrijven. Meer gedetailleerd de procedure Opnieuw instellen() opent een eerder gemaakt document en de procedure Herschrijven() Hiermee kunt u een nieuw bestand maken of een bestaand bestand wissen. Het bestand wordt gesloten met behulp van de speciale CloseFile-procedure. U kunt naar een Delphi-tekstbestand schrijven met behulp van procedures zoals Write of WriteLn.

Opnemen in Excel

In het geval dat het nodig is om op te nemen Excel Delphi, moet je een bepaald algoritme van acties gebruiken. Eerst wordt een variantarray gemaakt, vervolgens worden gegevens in deze array ingevoerd en wordt met één bewerking naar deze hele array geschreven Excel-bestand. Het is vermeldenswaard dat het opnemen in Excel zeer relevant is de laatste tijd, aangezien deze editor veel wordt gebruikt voor het ontwikkelen van verschillende rapporten en gedrukte formulieren.

Dit artikel is bedoeld voor beginners die willen leren werken met bestanden in Delphi. Het artikel bespreekt standaard I/O-bewerkingen met bestanden, typische fouten en methoden voor de preventie ervan.

In Delphi wordt een bestand weergegeven als een benoemde datastructuur, d.w.z. reeks van hetzelfde type gegevens. Grof gezegd is dit een enorme array, waarvan het aantal elementen vrijwel onbeperkt is. Om het werken met bestanden in Delphi gemakkelijker te maken, zijn elk apart bestand vertegenwoordigt een bestandsvariabele. Omdat het een variabele is, moet deze als variabele worden gedeclareerd. Maar eerst de eerste dingen.

Stap 1 - Een bestandsvariabele declareren

Bestandsvariabele in algemeen beeld gedeclareerd in de var-sectie, ongeveer als volgt:

F: bestand van type;

Bijvoorbeeld:

F: Bestand met geheel getal;

Opgemerkt moet worden dat tekstbestanden enigszins anders worden gedeclareerd:

En over het algemeen zijn tekstbestanden “bijzonder”. Sommige functies werken alleen met tekstbestanden. U kunt ook niet alleen een geheel getalbestand, een tekstbestand of een bestand van een ander type declareren, maar ook een bestand van uw eigen type of record door de type- of recorddeclaratie boven de bestandsvariabeledeclaratie te plaatsen. Bijvoorbeeld:

TDag = (MA, DI, WO, DONDER, VRIJ, ZA, ZO);

F: Bestand van TDay;

F: Bestand van TDay;

Houd er rekening mee dat de lengte van de stringvelden in het record duidelijk moet worden gedefinieerd (Naam: String)

Stap 2 - Een bestand toewijzen en openen

Nadat u een bestandsvariabele heeft gedeclareerd, moet u deze hieraan koppelen fysiek bestand op schijf. Dit kan gedaan worden met behulp van de AssignFile-procedure:

AssignFile(var F: Bestand; Bestandsnaam: String);

Bijvoorbeeld:

var F: Tekstbestand;

AssignFile(F, "tekst.txt");

Na voltooiing van de procedure wordt de bestandsvariabele F gekoppeld aan het bestand text.txt dat zich in de programmamap bevindt. En alle acties die met de variabele worden uitgevoerd, werken op dit bestand. De variabele kan echter worden vrijgegeven voor verder gebruik met een ander bestand met behulp van de CloseFile-procedure, maar daarover hieronder meer. Nu moet u het bestand op verschillende manieren openen, afhankelijk van uw behoeften. U kunt een nieuwe maken of een bestaande overschrijven met behulp van de Rewrite(F)-procedure. U kunt het bestand aan het einde van het bestand openen voor schrijven met behulp van de Append(F)-procedure. En het openen van het bestand om te lezen wordt uitgevoerd door de Reset-procedure.

Stap 3 - Standaard I/O-bewerkingen met bestanden

I/O zijn invoer-/uitvoerbewerkingen. Hier zullen we kijken naar het schrijven van gegevens naar een bestand en het lezen van die gegevens. Eerst opnemen. U kunt een variabele of constante naar een bestand schrijven van het type waarvoor het bestand is gedeclareerd. Als een bestand bijvoorbeeld als volgt is gedeclareerd: F: File of Integer, kunnen alleen gegevens van het type Integer ernaar worden geschreven. Als u gegevens van een ander type probeert te schrijven, genereert de compiler een foutmelding. Het schrijven naar een bestand wordt uitgevoerd met de procedures Write(; P1; [...,Pn]) en WriteLn(; P1; [...,Pn]). De tweede verschilt van de eerste doordat deze na het schrijven van de parameter de wagen naar een nieuwe regel verplaatst, d.w.z. volgende parameter wordt op een nieuwe regel geschreven. Hier is een voorbeeld van het gebruik van procedures:

var F: Tekstbestand;

Str:= "Wat tekst";

SchrijfLn(F, Str);

Write(F, "dit komt op de nieuwe voorraad");

write(F, "en dit staat op dezelfde regel");

Gegevens worden gelezen met behulp van de procedures Read(; V1; [...,Vn]) en ReadLn(; V1; [...,Vn]). Ze verschillen doordat nadat de parameter is gelezen door de ReadLn-procedure, de wagen naar een nieuwe regel gaat, zelfs als er nog gegevens waren. Hier is een voorbeeld:

var F: Tekstbestand;

ReadLn(F, Str2);//str2 bevat de gegevens die na str komen

Read(F, Str3);//str3 bevat de gegevens die op de nieuwe regel na str2 staan

Ik denk dat het allemaal niet zo ingewikkeld is.

Stap 4 - Het bestand sluiten

De bestandsvariabele moet na gebruik worden vrijgegeven, anders sluit het programma niet en genereert het een fout. Het vrijmaken van een bestandsvariabele kan ook handig zijn als u achtereenvolgens met meerdere bestanden moet werken. Nadat u met het eerste bestand hebt gewerkt, kunt u de variabele vrijmaken en aan een nieuw bestand koppelen. De procedure CloseFile(F: File) geeft de bestandsvariabele vrij. Ik denk dat er geen voorbeeld nodig is, omdat... ze heeft geen bijzondere kenmerken.

Ik denk dat het voor een beginner nog steeds moeilijk zal zijn om te begrijpen hoe hij met bestanden moet werken zonder voorbeelden. Dus laten we eens kijken eenvoudigste voorbeeld een programma dat met één klik op de knop de gebruiker om een ​​bestandsnaam vraagt ​​en de inhoud van TMemo opneemt. En als u op een andere knop drukt, vraagt ​​het programma opnieuw de bestandsnaam op, leest de opgenomen gegevens van daaruit uit en plaatst deze in TMemo. Ik weet dat schrijven en lezen in TMemo met speciale methoden kan worden georganiseerd. Maar dit is slechts een voorbeeld voor het artikel. Over het algemeen gooit u één TMemo en twee knoppen op het formulier. Wijzig de eerste knophandler in dit formulier:

procedure TForm1.Button1Click(Afzender: TObject);

Bestandsnaam: String;

AssignFile(F, Bestandsnaam);

voor i:= 0 tot Memo1.Lines.Count do

WriteLn(F, Memo1.Lines[i]);

Met deze knop wordt een tekstbestand opgeslagen. Dus in de var-sectie heb ik drie lokale variabelen gedeclareerd: F van het type TextFile is een bestandsvariabele voor tekstbestanden; Bestandsnaam van het type String zal dienen om de bestandsnaam op te slaan; En ik is van het type Integer - for loops. In de eerste regel vraag ik de gebruiker om de bestandsnaam. In het tweede geval associeer ik een bestandsvariabele met een fysiek bestand op schijf. De regel Rewrite(F) maakt een nieuw bestand aan of overschrijft een bestaand bestand. Om ervoor te zorgen dat de gegevens niet worden vervangen maar aan het einde van het bestand worden toegevoegd, moet deze regel worden vervangen door Append(F). Vervolgens komt er een lus van 0 tot het aantal van alle regels van Memo1. In de lus wordt de inhoud van alle Memo1-regels naar een bestand geschreven. Houd er rekening mee dat ik WriteLn gebruik om te schrijven nieuwe lijn. Als ik Write zou gebruiken, zouden alle Memo1-regels in het bestand één worden.

De tweede knophandler zou er ongeveer zo uit moeten zien:

procedure TForm1.Button2Click(Afzender: TObject);

Bestandsnaam, tmp: String;

FileName:= InputBox("Bestandsnaam", "Voer bestandsnaam in", "default.txt");

AssignFile(F, Bestandsnaam);

terwijl EOF(f) dat niet doet

Memo1.Lijnen.Toevoegen(tmp);

De toewijzing van lokale variabelen in deze procedure is vergelijkbaar met de vorige. De eerste en tweede regel zijn vergelijkbaar met de regels van de eerste knophandler. Reset(F) - Ik open het bestand om te lezen met behulp van de Reset-procedure. Vervolgens wordt er een lus gestart over het hele bestand (terwijl EOF(F) dat niet doet). De functie EOF(F: Bestand) retourneert waar wanneer het einde van het bestand is bereikt. De lus leest één regel uit het bestand in de tmp-variabele en voegt deze toe aan Memo1. Dat is alles, ik denk dat het vrij eenvoudig is. Het is echter gemakkelijk om het programma te misleiden om een ​​uitzondering te veroorzaken. Bij het lezen van een bestand kan de gebruiker bijvoorbeeld een naam opgeven bestaand bestand. Dan zal er een fout optreden. Vervolgens zullen we het hebben over manieren om een ​​programma tegen uitzonderingen te beschermen

Methode 1 - De eenvoudigste

Natuurlijk de eenvoudigste, maar genoeg effectieve manier beveiligingen kunnen worden georganiseerd met behulp van geneste try-except en try-finale-blokken. Je weet dat als er een uitzondering optreedt bij het uitvoeren van een instructie in de hoofdtekst van een try-except-blok, de uitvoering van verdere instructies stopt en wat zich tussen het behalve-einde bevindt, wordt uitgevoerd. Maar als er een uitzondering optreedt en CloseFile(F) wordt gevonden, wordt deze procedure niet uitgevoerd en kan het programma niet correct werken en eindigen. De oplossing voor dit probleem is het gebruik van geneste try-except en try-finale. Hier is een voorbeeld

MessageDlg("Fout bij werken met bestand", mtError, , 0);

Maar deze methode werkt mogelijk niet als er een poging is gedaan om een ​​niet-bestaand bestand te openen (er treedt een uitzondering op bij het uitvoeren van CloseFile(F)).

Methode 2 - Effectief

Het is bekend dat het programma zelf voor de afhandeling van uitzonderingen zorgt. Maar ze doet het niet altijd goed. Dat is waarom de beste oplossing Het zou leuk zijn om te bepalen op welk moment het bestand wordt geopend. Om dit te doen, moet u eerst de automatische afhandeling van uitzonderingen uitschakelen met de (I-) richtlijn. En je kunt het als volgt inschakelen: (I+). Controleer vervolgens de waarde van de IOResult-functie. Als het bestand succesvol is geopend, retourneert het 0. Hier is een voorbeeld:

als IOResult<>0 dan

MessageDlg("Bestand "+PChar(Bestandsnaam)+ " bestaat niet", mtError, , 0);

UITGANG; //kan niet doorgaan

Voeg dit alles in de bestandsleesprocedure in (in het bovenstaande voorbeeld) in plaats van de regel Reset(F). U kunt zich ook tegen fouten verzekeren door deze constructie in de procedure voor het opslaan van bestanden in te voegen in plaats van in de regel Rewrite.

Benoemd geheugengebied ingeschakeld externe media(schijf) wordt aangeroepen bestand. Elk bestand heeft Naam. Informatie, dat in een bestand is opgeslagen, is een reeks elementen van hetzelfde type. Maat een bestand wordt doorgaans alleen beperkt door de capaciteit van het apparaat waarop het is opgeslagen, waardoor het mogelijk is grote hoeveelheden informatie te verwerken.

Aankondigingsmethode bestand is afhankelijk van het type. Er zijn drie soorten bestanden:

tekst;

getypt;

ongetypeerd.

Tekstbestand, bestaat uit een reeks van willekeurige tekens. De tekens vormen regels, die elk eindigen met een regeleindeteken. Het einde van het bestand zelf wordt aangegeven door het symbool "einde van bestand". Bij het schrijven van informatie naar een tekstbestand worden alle gegevens omgezet naar een tekentype en in deze vorm opgeslagen. U kunt een tekstbestand bekijken met elk teksteditor.

Beschrijving van het tekstbestand:

var variabelenaam: Tekstbestand;

Getypt bestand bestaat uit elementen van hetzelfde type, waarvan het aantal niet vooraf bepaald is en elk kan zijn. Het eindigt ook met het symbool "einde van bestand". Gegevens in een getypt bestand worden opgeslagen in binaire codes en worden niet bekeken teksteditors. De declaratie van dergelijke bestanden ziet er als volgt uit:

variabele_naam: bestand van type;

IN ongetypeerde bestanden informatie wordt gelezen en geschreven in het formulier blokken van een bepaalde grootte kunnen ze gegevens van elk type en elke structuur opslaan. Beschrijving van het ongetypeerde bestand:

var variabelenaam: bestand;

Voor toegang tot bestanden gebruik een speciaal bestandsvariabele.

Bijvoorbeeld:

c:bestand met geheel getal;

Voor communicatie bestandsvariabele met een bestand op schijf gebruikt u de procedure:

AssignFile(variabele, bestandsnaam);

hier is variabele de naam van een variabele van welke dan ook bestandstype, bestandsnaam is een tekenreeks die bevat volledige naam bestand (als het pad naar het bestand niet is opgegeven, wordt ervan uitgegaan dat het zich in huidige map).

Bijvoorbeeld:

S:=’tekst.txt’;

toewijzen(f,’d:\tp\tmp\abc.dat’);

Voor een bestaand bestand openen gebruik de werkwijze:

Reset(bestand_variabele);

Na het openen van een bestand is het eerste onderdeel ervan beschikbaar.

Om een ​​nieuw bestand aan te maken of informatie uit een bestaand bestand te verwijderen, gebruikt u de volgende procedure:

Herschrijven(bestandsvariabele);

Na executie diverse operaties het bestand zou moeten zijn gesloten. Gebruik hiervoor de procedure

SluitBestand(bestandsvariabele);

Gegevensregistratie naar een tekstbestand wordt uitgevoerd door middel van procedures

Write(variabele, expressielijst);

Writeln(variabele, expressielijst);

waarbij expression_list een teken, geheel getal, real, string of is Booleaanse typen, dat wordt geschreven naar het bestand dat aan de bestandsvariabele is gekoppeld.

De Writeln-procedure voegt een regelterminator toe aan het einde van elke regel.

VOORBEELD. Een subroutine die op schijf creëert D bestand abc.txt en schrijft de tafel van vermenigvuldiging erin.

var f:Tekstbestand; ik,j:byte;

AssignFile(f,"d:\abc.txt");

voor i:=2 tot 9 doen

voor j:= 2 tot 9 doen

schrijf(f,i,"*",j,"=",i*j," ");

Gegevens lezen uit het bestand wordt door de procedure opeenvolgend vanaf het begin van het bestand uitgevoerd

Readln(variabele, variabele_lijst);

hier vermeldt de variabelen_lijst de variabelen waarin de gegevens die worden gelezen uit het bestand dat aan de bestandsvariabele is gekoppeld, zullen worden geschreven.

De Readln-procedure gaat, na het lezen van het volgende element uit een bestand, verder naar de volgende regel.

Door de volgende subroutine aan te roepen, verschijnt de tekst uit het bestand op het formulier in het bewerkingsvenster D:\abc.txt:

procedure TForm1.Button1Click(Afzender: TObject);

een:tekenreeks; ik:geheel getal;

AssignFile(f1,"D:\abc.txt");

voor i:=1 tot 8 doen

Memo1.Lijnen.Toevoegen(a);

Ook van toepassing op getypte bestanden leesprocedures En records

Lezen(variabele, lijst met variabelen);

Write(variabele, expressielijst);

alleen de schrijf- en leesexpressietypen moeten overeenkomen met het gedeclareerde bestandstype. De Writeln- en Readln-procedures zijn niet van toepassing op getypte bestanden.

Voor door een getypt bestand bladeren gebruik de werkwijze:

Zoeken(variabel, getal);

Met deze procedure kunt u naar een element navigeren met opgegeven nummer, dat wil zeggen, het voert uit directe toegang tot bestandscomponenten. Bij directe toegang worden bestandscomponenten genummerd van 0 tot n-1, waarbij n het aantal componenten in het bestand is.

U kunt ook de volgende functies gebruiken om rechtstreeks toegang te krijgen tot de componenten van een getypt bestand:

bestandsgrootte(variabele) – retourneert het aantal echte componenten in bestand openen geassocieerd met file_variable (voor leeg bestand de functie retourneert 0);

filepos(variabele) – retourneert de waarde van de huidige positie in het geopende bestand dat is gekoppeld aan de bestandsvariabele (als het bestand zojuist is geopend, retourneert de functie nul; na het lezen van de laatste component uit het bestand komt de functiewaarde overeen met de filesize-waarde, die aangeeft dat het einde van het bestand is bereikt).

De zoekprocedure en de functies bestandsgrootte en filepos werken niet met tekstbestanden. De volgende routines werken met zowel getypte als tekstbestanden:

Hernoemen(variabele, bestandsnaam)

hernoemt het gesloten bestand dat is gekoppeld aan de bestandsvariabele volgens de naam die is opgegeven in de bestandsnaamregel;

Wissen (variabel) – verwijdert gesloten dossier, geassocieerd met een bestandsvariabele;

Eof(variabele) evalueert naar true als het einde van het bestand geassocieerd met file_variable wordt bereikt, anders false;

VOORBEELD. De onderstaande subroutine werkt als volgt. Opent een echt bestand d:\abc.dat en er wordt een bepaald bedrag in geschreven echte cijfers, berekend met de formule. Het is niet mogelijk om het gemaakte bestand te bekijken, omdat de informatie daarin in binaire codes wordt weergegeven.

procedure TForm1.Button1Click(Afzender: TObject);

AssignFile(f,"d:\abc.dat");

n:=StrToInt(Bewerken1.Text);

voor i:=1 tot n doen

a:= sqr(i)/sqrt(i);

Om ervoor te zorgen dat het schrijven naar het bestand d:\abc.dat is succesvol gebeurd, laten we de waarden ervan weergeven in het bewerkingsvenster:

procedure TForm1.Button1Click(Afzender: TObject);

f1:bestand van echt;

AssignFile(f1,"D:\abc.dat");

terwijl eof (f1) dat niet doet

Memo1.Lijnen.Add(FloatToStr(a));

TAAK. Op schijf E er is een bestand met gehele getallen abc.int, verwissel de maximale en minimale elementen.

Het volgende programma werkt als volgt. De componenten van het bestand worden in een array gelezen. De array-elementen worden weergegeven in het Memo1-veld. Vervolgens worden de minimale en maximale elementen van de array en hun indices doorzocht. De maximale en minimale componenten worden op de overeenkomstige posities naar het bestand herschreven.

Ten slotte worden de elementen van het geconverteerde bestand weergegeven in het Memo2-veld.

procedure TForm1.Button1Click(Afzender: TObject);

f:bestand met geheel getal;

a: array van gehele getallen;

i,nmax,nmin:byte; max,min:geheel getal;

AssignFile(f,"e:\abc.int");

voor i:=0 tot bestandsgrootte(f)-1 wel

Memo1.Lines.Add(FloatToStr(a[i]));

maximaal:=a; nmax:=0;

min:=a; nmin:=0;

voor i:=1 tot bestandsgrootte(f)-1 wel

als a[i]>max dan

als een[ik]

voor i:=0 tot bestandsgrootte(f)-1 wel

Memo2.Lines.Add(FloatToStr(a[i]));

We zullen in detail bekijken hoe u bestanden kunt kopiëren, verwijderen en hernoemen. Laten we leren hoe we informatie in getypte bestanden kunnen lezen en schrijven.

Bestanden kopiëren met .

Om dit te doen, hoeven we slechts één functie aan te roepen, die specifiek bestanden kopieert. Dit is de functie CopyFile(). Het heeft drie parameters, waarvan er twee vereist zijn. Hier is de volledige syntaxis.
CopyFile("pad naar het oorspronkelijke bestand", "Pad naar waar u wilt kopiëren", of u het wilt overschrijven of niet)

Voorbeeld: CopyFile("D:sekretBD.txt","C: ame.txt", true);

In de eerste parameter kunt u niet alleen het volledige pad naar het bestand opgeven. Als we bijvoorbeeld het pad “sekretBD.txt” opgeven, zoekt ons programma naar dit bestand in zijn directory. De naam en toestemming moeten precies zo worden opgegeven als voor het bestand, anders zal het programma het bestand eenvoudigweg niet vinden.
In de tweede parameter kunt u ook een relatief pad opgeven en daar kunt u de bestandsnaam en extensie naar wens opgeven. Die. Met deze functie kunt u ook hernoemen.
De derde parameter is verantwoordelijk voor het overschrijven van het bestand. Als we true opgeven, wordt het bestand niet overschreven, en als we false opgeven, overschrijft het programma het bestand.

Bestanden hernoemen met

De functie RenameFile() is verantwoordelijk voor het hernoemen van bestanden. Het heeft 2 parameters. Hier is de volledige syntaxis
RenameFile("pad naar bestand", "nieuwe naam");
Om eerlijk te zijn, ben ik niet bijzonder blij met de syntaxis van deze functie. Daarin moet u ook het volledige pad in beide parameters opgeven. Die. als we bijvoorbeeld zo schrijven

Bestand hernoemen("C:2.txt","3.txt");

Vervolgens kopieert het het bestand naar de programmamap. Die. Het blijkt dat het ook als kopie kan dienen. Het is een beetje vreemd.

Bestanden verwijderen met

Nou, alles is hier vrij eenvoudig. De functie die gebruikt kan worden om een ​​bestand te verwijderen heet als volgt:

DeleteFile("C:mijnprofiel.txt");

Het enige is dat het bestand niet altijd 100% wordt verwijderd. Als het bestand beveiligd is, kan ze het niet verwijderen.

Werken met getypte bestanden in

Wat is een getypt bestand? Dit is een bestand met een specifieke structuur. Meestal bestaat deze structuur uit records en basistypen. Over het algemeen is het belangrijk dat het type een bekende vaste grootte heeft, dus je kunt het stringtype niet gebruiken, je moet het als volgt doen: String[N].
Eerst moeten we een variabele declareren waarin de gegevens uit het bestand worden opgeslagen. Dit wordt als volgt gedaan:

Var f: bestand van<Тип>
Bijvoorbeeld f: bestand met string;

Vervolgens moeten we verbinding maken met het bestand. Hiervoor bestaat de opdracht AssignFile. Om te bellen, moet u twee parameters opgeven: dit is de variabele die we hierboven hebben aangegeven en het pad naar het bestand. Bijvoorbeeld

AssignFile(f,"C:delphi.ini");

Nu moet het bestand worden geopend. Het kan op twee manieren worden geopend: met of zonder naslijpen. De Rewrite-methode opent een bestand nadat het voor het eerst is gemaakt. Die. als het bestand zich niet in het pad bevindt dat we opgeven, wordt het aangemaakt. Als er al een dergelijk bestand bestond, wordt dit verwijderd en wordt er opnieuw een schoon bestand gemaakt. De Reset-methode opent het bestand en plaatst de aanwijzer helemaal aan het begin van het bestand. Maar deze methode is gevaarlijk, want als het in de verbinding opgegeven bestand niet bestaat, crasht het programma met een fout. Om de Reset-functie correct te gebruiken, moet u de compiler vertellen dat hij fouten moet uitschakelen. Dit wordt gespecificeerd door de richtlijn ($I-), d.w.z. De volledige syntaxis voor de resetfunctie zou zijn:

($I-)
Opnieuw instellen(f);
($I+)

Hierna moet u controleren of het bestand is geopend of niet. Dit kan gedaan worden met behulp van de IOResult-functie. Als het niet nul is, is alles succesvol.
Volledige syntaxis:

($I-)
Opnieuw instellen(f);
($I+)
Als IOresultaat<>0 dan<ваш код>

De FileExists-functie helpt u ook bij het controleren. Het moet het pad naar het bestand aangeven.
Om een ​​bestand te lezen, gebruikt u de functie Read(), die twee parameters specificeert: de bestandsvariabele en het recordtype, in ons geval is dit string. Syntaxis:

Om naar een bestand te schrijven, gebruikt u de functie Write(), die dezelfde twee parameters specificeert: de bestandsvariabele en het recordtype, in ons geval is dit string. Syntaxis:

Hoewel eof(f) dat niet doet
Lezen(f,String);

Er is ook een zoekfunctie, waarmee we naar de plaat kunnen gaan waarin we geïnteresseerd zijn. We moeten bijvoorbeeld toegang krijgen tot record 20 en we doen dit:

Er is ook een truncate-functie, waarmee we alle vermeldingen in een bestand kunnen verwijderen, beginnend vanaf de pointerpositie. De positie kan worden opgegeven met behulp van de zoekfunctie, wie het niet begreep.

Nadat u alle bewerkingen met het bestand hebt voltooid, moet u het sluiten met de functie CloseFile(f);
Dat is het. Hiermee wordt de les afgesloten. Tot ziens op de site!