Lucru clasic cu fișiere în Delphi. Delphi scrie în fișier

20.07.2019 Panoul Straturi

Când despre care vorbim despre funcționarea unui program cu un fișier text, implică proceduri de introducere a datelor dintr-un fișier în program sau, dimpotrivă, scrierea acestor date într-un fișier de către program. Acceptabil pentru un fișier text lucru simplu cu un fișier fără mecanisme suplimentare speciale care sunt utilizate pentru a lucra cu fișiere specializate, cum ar fi atunci când încărcați date din Excel sau lucrați cu un program de bază de date. Desigur, Delphi are capacitatea de a lucra cu fișiere folosind componente. Dar acest articol discută mecanismul de lucru direct cu un fișier text fără a utiliza componente suplimentare.

Deci, în general, lucrul cu un fișier constă din următorii pași:

1. conexiune la un fișier – conexiune cu fișier extern, indicarea modului de conectare;

2. efectuarea de operații de scriere într-un fișier sau citire dintr-un fișier;

3. Finalizarea lucrării cu fișierul.

Conectarea la un fișier

Pentru a conecta un program cu un fișier, se folosește o variabilă specială - „variabilă fișier”. Este declarată în același mod ca orice variabilă din Delphi. Tipul acestei variabile poate fi Fişier pentru cele tastate (stocarea datelor anumit tip) sau puteți specifica Fișier text, care va indica tipul de fișier text obișnuit. Declarație variabilă:

var
f:TextFile;

Codul executabil al programului se conectează la un fișier extern:

AssignFile(f, "input.txt");

Echipă AssignFile, asociază o variabilă de fișier cu un fișier extern. Al doilea parametru specifică adresa fișierului. Poate fi specificat relativ sau absolut. Dacă specificați doar numele fișierului, programul va încerca să-l găsească în același director în care se află el însuși. Calea absolută este specificată de pe discul rădăcină:

AssignFile(f, „C:\myprog\input.txt”);

Utilizarea unui director relativ face posibil să nu fii legat de el unități specifice si adrese. De exemplu:

AssignFile(f, "data\input.txt" ); // într-un subfolder relativ la directorul cu programul
AssignFile(f, "..\input.txt" ); // cu un nivel deasupra directorului programului
AssignFile(f, "..\data\input.txt"); // într-un subdosar la un nivel deasupra directorului programului

După ce se realizează conexiunea, se efectuează o procedură care setează modul de lucru cu fișierul. Practic este modul citire sau scriere. Aceste moduri sunt atribuite prin proceduri Resetare()(pentru citire) și rescrie()(pentru consemnare):

Resetare(f);
Rescrie(f);

* Pentru echipa Rescrie() Trebuie avut în vedere că atunci când este executat, fie creează fișierul specificat în variabila fișier, fie dacă acesta există deja, suprascrie din nou fișierul, ștergându-l pe cel vechi fără niciun avertisment.

Oricare dintre comenzile de mai sus poate fi folosită fără comandă AssignFile(). Pentru a face acest lucru, trebuie doar să specificați calea către fișier ca al doilea parametru. Astfel, va lega imediat fișierul la variabila fișier și va atribui modul de operare cu acest fișier:

Resetare(f, "C:\myprog\input.txt"); // citit
Rescrie(f, "C:\myprog\input.txt"); // înregistrare

Operații cu fișiere

Pentru a citi dintr-un fișier, trebuie să atribuiți un mod de citire și să utilizați comanda Readln(), care va introduce câte o linie din fișier într-o variabilă șir. Apoi puteți lua măsurile necesare cu această modificare.

Readln(f, s);

De obicei, un operator de buclă este folosit pentru a încărca toate liniile dintr-un fișier. Pentru a determina dacă fișierul s-a încheiat, se folosește funcția EOF()(Sfârșitul fișierului). Acest lucru creează o buclă în care toate liniile fișierului sunt introduse secvențial într-o variabilă șir și se termină când fișierul se termină:

Readln(f, s);
Sfârşit ;

Pentru înregistrare, atribuiți modul de înregistrare unui fișier și comenzii Scrieți()înregistrarea se face linie cu linie.

Scrie (f, „text”);

Închiderea unui fișier

După ce ați terminat lucrul cu fișierele, mai ales dacă datele sunt scrise în ele, este necesar să închideți corect lucrul cu variabila fișier. Acest lucru se face pentru a salva toate modificările aduse fișierului.

CloseFile(f);

Exemple de lucru cu fișiere text în Delphi

Citirea unei singure valori dintr-un fișier într-o variabilă:

var
f:TextFile;
s: șir;
ÎNCEPE
AssignFile(f, "input.txt");
Resetare(f);

Readln(f, s);

CloseFile(f);
Sfârşit ;

Încărcați toate liniile unui fișier în componenta Memo:

var
f:TextFile;
s: șir;
ÎNCEPE
AssignFile(f, "input.txt");
Resetare(f);

în timp ce (nu EOF(f)) începe
Readln(f, s);
myMemo.Lines.Add(i);
Sfârşit ;

CloseFile(f);
Sfârşit ;

Trebuie remarcat faptul că pentru această sarcină este mai ușor să utilizați comanda componentei Memo în sine LoadFromFile().

myMemo.Lines.LoadFromFile("input.txt");

Scrieți linia în fișier:

var
f:TextFile;
ÎNCEPE
AssignFile(f, "input.txt");
Rescrie(f);

Scrie (f, „Textul meu”);

CloseFile(f);
Sfârşit ;

Scrie la fișier text toate liniile din componenta Memo:

var
f:TextFile;
i: întreg;
ÎNCEPE
AssignFile(f, "input.txt");
Rescrie(f);

pentru i:= 0 la myMemo.Lines.Count - 1 do
Writeln(f, myMemo.Lines[i]);
CloseFile(f);
Sfârşit ;

În ceea ce privește citirea dintr-un fișier în Memo, și aici există o comandă specială:

myMemo.Lines.SaveToFile("input.txt" );

Lecția 15. Lucrul cu fișierele

În această lecție ne vom uita la un subiect foarte important în programare - lucrul cu fișierele.
În aproape orice program trebuie să copiați, să deschideți, să schimbați, să salvați și, uneori, să ștergeți fișiere.

După cum știți, fișierele au diverse formateși se aplică lor diverse programe pentru prelucrare. De exemplu, fișiere imagine BMP, text fișiere TXT etc. Fișierele au nume diferite și o extensie specifică, care în mediul MS-DOS are maximum trei caractere. Dacă fișierul are o extensie RAR, atunci utilizatorul și sistemul de operare sistemul stie că acesta este un arhivator și windowsw utilizează instrumentele specificate într-o secțiune specială de registru pentru a procesa acest fișier.

Copierea fișierelor

Funcția CopyFile este folosită pentru a copia fișiere. Formatul său este astfel:

CopyFile(Fișier_sursă, Fișier_Scrire, steagul_Suprascriere);

unde: Source_file – calea completă și numele fișierului copiat;

Write_file – calea completă și numele fișierului în care este copiat fișierul sursă;

Overwrite_flag – dacă fișierul va fi sau nu suprascris dacă acesta există deja (adevărat – nu va fi, fals – va fi suprascris).

CopyFile este o funcție care returnează un semnal dacă operațiunea de copiere a avut succes sau nu.

De exemplu, următoarea linie:

dacă nu CopyFile("c:\command.com","c:\1.com",true), atunci ShowMessage("Eroare de copiere");

va copia fișierul command.com în fișierul 1.com numai dacă acesta din urmă nu există, altfel va afișa un mesaj de eroare de copiere.

Mutarea fișierelor

Funcția MoveFile este folosită pentru a muta fișiere. Ea are următorul format:

MoveFile(Fișier_sursă, Fișier_Scrire);

Parametrii săi sunt similari cu comanda de mai sus, cu excepția absenței steagului de rescriere.

dacă nu MoveFile("c:\1.com","c:\2.com"), atunci ShowMessage ("Eroare de mutare");

Redenumirea fișierelor

Funcția RenameFile

dacă nu RenameFile("c:\2.com","c:\3.com"), atunci ShowMessage ("Redenumire eroare");

Toate comenzile de mai sus au inițiale și dosar final este de tip PChar. Este un tip de șir terminat nul. Este posibil să fi auzit de acest format de date șir înainte.

Un șir foarte lung poate fi stocat într-o astfel de variabilă. Dimensiunea sa este limitată de prezența unui octet nul la sfârșit. Teoretic, o astfel de variabilă poate avea o dimensiune infinită. În practică, este limitat de dimensiunea memoriei alocate programului (2GB).

Conversia unei variabile șir obișnuite, de tip String, în PChar este efectuată de funcția:

PChar(variabilă_șir).

procedura TForm1.Button1Click(Expeditor: TObject);

Var InDir,OutDir:String; // declararea variabilelor șir

ÎNCEPE

InDir:="c:\1\"; // directorul fișierelor sursă

OutDir:="c:\2\"; // directorul de fișiere de scris

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

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

Sfârşit;

Aici avem operația de concatenare a două variabile șir.

Rezultatul acestei proceduri va fi copierea fișierelor c:\1\1.txt și c:\1\2.txt în directorul c:\2. Fișierele sunt copiate sub aceleași nume.

Ștergerea fișierelor

Funcția DeleteFile

dacă nu DeleteFile("c:\3.com"), atunci ShowMessage("Delete error");

Lucrul cu fișiere text. Citirea dintr-un fișier text

În lecțiile anterioare, noi, în componenta Memo, am făcut procesul de încărcare și scriere a unui fișier text după cum urmează:

Memo1.Lines.SaveToFile(FileName);

// salvează

Toate acestea se datorează proprietății Lines, care stochează linii.
Următorul exemplu de procesare a unui fișier text este foarte asemănător cu cel din Pascal. Oameni cu cunoştinţe

poate simți diferența deoarece există unele diferențe.

procedureTForm1.Button1Click(Expeditor: TObject);

Varf:TextFile; // fișier declarație variabilă Sf:Şir

ÎNCEPE

; // variabilă șir

AssignFile(f,"c:\1.txt"); // leagă numele fișierului la o variabilă de fișier

($I-) // dezactivează verificarea erorilor I/O

Resetare(f); // deschide fișierul pentru citire

($I+) // activează monitorizarea erorilor I/O<>0 ifIOResult apoi // dacă există eroare de deschidere

ÎNCEPE

, Asta

ShowMessage(„Eroare la deschiderea fișierului C:\1.TXT”);

Ieșire; // ieși din procedură dacă există o eroare la deschiderea unui fișier;

Sfârşit în timp ce nu EOF(f) do // Nu încă sfârşitul dosarului

ÎNCEPE

face o bucla:

Ieșire; // ieși din procedură dacă există o eroare la deschiderea unui fișier;

ShowMessage(st); // scoate un șir către utilizator

Sfârşit;

CloseFile(f); // închide fișierul

Permiteți-mi să comentez câteva rânduri din acest exemplu.

Comanda AssignFile leagă un șir de cale de fișier la o variabilă de fișier. Toate operațiunile ulterioare cu variabila fișier sunt efectuate automat pe fișierul specificat. Pentru a evita confuzia, specificați calea completă către fișier. ($I-) și ($I+) sunt directive către compilator pentru a dezactiva și, respectiv, a activa verificarea erorilor I/O în acest moment. În acest caz, cândîncercare nereușită

IOResult este o variabilă care stochează codul de eroare al ultimei operațiuni I/O. Dacă este zero, atunci ultima operație a fost finalizată cu succes.

EOF(Fișier) – o funcție care returnează semnul de sfârșit al fișierului. Aceste. arată dacă s-a ajuns sau nu la sfârșitul fișierului deschis.

ReadLn(File, Variable) – procedură de citire a unei variabile dintr-un fișier. Spre deosebire de comanda Citire, citește o linie care se termină cu un caracter de linie nouă sub codurile 13 și 10 (tasta Enter).

CloseFile(File) – procedură de închidere a unui fișier deschis anterior.

Lucrul cu fișiere text. Scrierea într-un fișier text

Să ne uităm la un exemplu:

procedura TForm1.Button1Click(Expeditor: TObject);

Var f:TextFile; // pointer către fișierul text

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

// leagă numele la o variabilă

Anexează(f);<>0 // deschide fișierul pentru adăugare dacă IORrezultat

apoi // dacă există o eroare la deschidere (de exemplu, nu există niciun fișier)

Anexează(f);<>Rescrie(f);

// creează

fișier nou

0 apoi // eroare de creare a fișierului

ShowMessage(„Eroare la crearea fișierului C:\1.TXT”);

WriteLn(f,"Bună ziua");

// scrie într-un fișier un șir cu caractere newline

CloseFile(f);

// închide fișierul Procedura Append deschide un fișier pentru scriere și setează indicatorul de scriere la sfârșitul fișierului, de exemplu. toate liniile adăugate la fișier vor fi scrise la sfârșitul fișierului.

În cazul nostru, chiar la începutul fișierului, 1.txt poate să nu fie pe disc, așa că comanda de deschidere a fișierului pentru adăugare va provoca o eroare. În acest caz, se declanșează propria noastră verificare a erorilor și se execută comanda de creare a fișierului. Scrierea și citirea datelor non-text dintr-un fișier Să luăm în considerare un exemplu în care un program, la ieșire, își salvează dimensiunea și poziția ferestrei pe ecran într-un fișier și, la lansarea ulterioară, restabilește starea pe care o avea la ieșire. Programul constă din două proceduri OnShow și OnClose pentru fereastra Form1 a programului. procedură TForm1.FormShow(Expeditor: TObject);

Var

ÎNCEPE

fişier

Resetare(f);

Întreg; // variabilă fișier, tastați întreg I:Număr întreg; // variabilă întreagă<>0 ifIOResult AssignFile(f,"pos.ini");

($I-)

($I+)

dacă

($I+)

IORrezultat

($I+)

Ieșire;

CloseFile(f);

Ieșire; // ieși din procedură dacă există o eroare la deschiderea unui fișier;

// închide fișierul Form1.Top:=i; // poziția de sus a ferestrei var Citiți(f,i);

Form1.Width:=i; // latimea ferestrei

1. Fișierul trebuie să fie deschis. Alte aplicații nu ar trebui să interfereze cu lucrul cu fișierul, sistemul monitorizează cu atenție acest lucru. În același timp, sistemul stabilește în ce scopuri este deschis fișierul. Există mai multe opțiuni aici: pentru a citi sau pentru a face modificări.

După ce un document este creat sau deschis, sistemul primește un identificator special, care va fi folosit ca indicator către acest fișier în toate procedurile ulterioare de procesare.

3. După ce toate acțiunile necesare au fost finalizate și dosarul a fost scris, documentul este închis. Din acest moment, devine disponibil pentru alte aplicații complet fără restricții. Este de remarcat faptul că închiderea fișierului garantează că toate modificările efectuate vor fi salvate. Astfel, scrierea datelor necesare în fișierul Delphi este finalizată cu succes.

Dacă această sarcină pare destul de complicat, atunci poți apela la profesioniști care, pe lângă Delphi, știu tot ce trebuie să știi despre administrarea Linux.

Scrierea într-un fișier text Delphi

În Delphi, un fișier este reprezentat ca o secvență de date de același tip. Cu alte cuvinte, aceasta este o matrice destul de mare, a cărei dimensiune este practic nelimitată. Pentru a facilita scrierea într-un fișier text Delphi, fiecare document este reprezentat ca o variabilă de fișier.

Pentru a lucra cu documente text este folosit tipul TextFile, care este scris astfel:

Variabila Var: Tastați TextFile;
Pentru a obține acces la fișier, utilizați procedura AssignFile(). Odată obținut accesul la fișier, acesta poate fi deschis folosind procedurile Resetează, rescrie. Mai detaliat, procedura Resetare() deschide un document creat anterior și procedura Rescrie() vă permite să creați un fișier nou sau să ștergeți unul existent. Fișierul este închis utilizând procedura specială CloseFile. Puteți scrie într-un fișier text Delphi folosind proceduri precum Write sau WriteLn.

Inregistrare in excel

Dacă trebuie să înregistrați în excel Delphi, trebuie să utilizați un anumit algoritm de acțiuni. Mai întâi, este creată o matrice variantă, apoi datele sunt introduse în această matrice și, folosind o singură operație, întreaga matrice este scrisă într-un fișier Excel. Este demn de remarcat faptul că înregistrarea în excel este foarte relevantă în în ultima vreme, deoarece acest editor este utilizat pe scară largă pentru dezvoltarea diferitelor rapoarte și formulare tipărite.

Creați un nou proiect Delphi. În primul rând, vom dezvolta interfața programului. Să modificăm unele proprietăți ale formei principale. Mai întâi de toate, atribuiți valoarea corespunzătoare proprietății Caption (titlul formularului) - de exemplu, Lucrul cu fișierele. Deoarece fereastra programului nostru ar trebui să fie întotdeauna deasupra tuturor celorlalte ferestre, ar trebui să setăm proprietatea FormStyle la fsStayOnTop. Nu vom modifica alte proprietăți ale formularului.

Așezați în stânga colțul de sus formulare, una deasupra celorlalte două componente Categoria de etichetă Standard. Pentru eticheta de sus, setați proprietatea Caption la Ce: și pentru a doua la Unde:. Lângă etichete, plasați o componentă Editare (câmp de intrare) a categoriei Standard. Setați proprietatea Nume a câmpului de sus la de la și proprietatea Nume a câmpului de jos la unde. Setați proprietățile from.Text și where.Text la căile implicite, de exemplu: c:\1.txt și d:\2.txt.

Pentru a nu deranja utilizatorul cu copierea sau introducerea manuală a căilor de fișiere, vom folosi casete de dialog standard pentru deschiderea și salvarea fișierelor. Caseta de dialog pentru deschiderea fișierului corespunde componentei categoriei OpenDialog Dialoguri, și caseta de dialog de salvare - componenta SaveDialog din aceeași categorie. Să plasăm aceste componente pe formular. Pentru comoditate, să schimbăm valoarea proprietății OpenDialog1.Name în Open1 și valoarea proprietății SaveDialog1.Name în Save1.

În dreapta câmpurilor de la și unde vom plasa butoane pentru apelarea casetei de dialog de prezentare generală (componente din categoria Buton Standard). Setați proprietatea Legendă a acestor butoane la Revizuire sau pur și simplu adăugați puncte. Dacă doriți, puteți modifica dimensiunea butoanelor.

Plasați componenta Etichetă categorie pe formular sub câmpul unde Standardși setați proprietatea Caption la File Size:. În dreapta acestei etichete, plasați o altă componentă Label, ștergând proprietatea Caption - această etichetă va afișa dimensiunea fișierului în curs de procesare.

Mai jos vom plasa două butoane (componentele Buton), le vom atribui proprietăților Subtitrări valorile Copiere și Tăiare. Sub aceste butoane vom plasa componente care vor fi folosite pentru selectarea și ștergerea fișierelor: componenta Editare pentru introducerea căii către fișier, un buton pentru apelarea casetei de dialog de navigare și un buton pentru ștergerea fișierului.

Să setăm proprietatea Edit1.Name la Del și proprietate Text– calea implicită. buton Recenzie plasați-l în dreapta și butonul Ștergeți fișierul- sub câmpul Del.

Forma rezultată ar trebui să corespundă cu Fig. 2.1.

Orez. 2.1. Formular Lucrul cu fișiere

Dezvoltarea codului programului

Să dezvoltăm o procedură pentru copierea unui fișier. Acest lucru ar putea fi implementat folosind WinAPI, dar în acest caz procedura, deși ar fi mai puțin greoaie, ar fi „legată” de sistem, ceea ce este nedorit pentru programe, deci este mai bine să folosiți bibliotecile Delphi.

Mai întâi, să declarăm procedura noastră (să o numim doit) ca membru privat al clasei de formulare:

Vom crea implementarea procedurii în secțiunea de implementare:

procedura TForm1.doit();

f1, f2: fișier de octet;//Lucrați cu primul și al doilea fișier

sor: Byte;//Pentru copierea octet cu octet

sizez: LongInt;//Stochează dimensiunea fișierului

($I-)//Dezactivați directiva care urmărește erorile

încerca//Începutul blocului de gestionare a excepțiilor

//Asociați variabila fișier f1 cu primul fișier

AssignFile(f1, from.Text);

//Asociați variabila fișier f2 cu al doilea fișier

AssignFile(f2, where.Text);

Resetare(f1); //Deschide primul fișier pentru citire

sizez:= Trunc(FileSize(f1)); //Determină dimensiunea fișierului

//Afișează dimensiunea fișierului pentru utilizator

Label4.Caption:= IntToStr(sizez div 1024) + „KB”;

ÎNCEPE//Până când se ajunge la sfârșitul primului fișier

//Citește un octet din primul fișier

BlockRead(fl, politist, 1);

//Scrieți un octet în al doilea fișier

BlockWrite(f2, cop, 1);

Închideți fișierul (f1); //Închide primul fișier

Închideți fișierul (f2); //Închide al doilea fișier

Sfârşit;//Sfârșitul blocului de gestionare a excepțiilor

dacă IORrezultat<> 0 //Dacă apare o eroare I/O

apoi MessageDlg ("Eroare la copierea fișierului!", mtError, ,0)//mesaj de eroare

(Dacă nu au existat erori, atunci vom afișa o fereastră care indică finalizarea cu succes a copierii)

ShowMessage("Copiat cu succes!");

⇘ Diverse constructe ale limbajului Object Pascal (comentarii, operatori de ramificare, gestionarea excepțiilor etc.) sunt discutate în Anexa D.

Această procedură va fi utilizată la copierea și transferul fișierelor. Mai întâi deschidem fișierele pe care utilizatorul le-a selectat și apoi verificăm dacă au existat erori la deschiderea lor. Dacă nu au existat erori, atunci afișăm utilizatorului dimensiunea fișierului sursă și începem să citim octeți din primul fișier, scriindu-i în al doilea. Dacă copiarea este finalizată și nu au apărut erori, afișăm un mesaj care indică faptul că copierea a avut succes.

Procedura doit este apelată când se face clic pe butonul Copie:

procedura TForm1.Button1Click(Expeditor: TObject);

La un clic pe un buton Tăiați Copierea normală ar trebui să aibă loc, urmată de ștergerea fișierului copiat:

bagatelă;//copie

DeleteFile(from.Text); //sterge fisierul sursa

Acum să creăm proceduri pentru selectarea și salvarea unui fișier folosind standard casete de dialog. Pentru a selecta primul fișier (sursă), creați următorul handler de evenimente OnClick (butonul Button2 corespunde câmpului de la):

apoi from.Text:= Open1.FileName

Când butonul este apăsat Recenzie Se deschide caseta de dialog pentru selectarea fișierului (Open1.Execute). Dacă utilizatorul a făcut clic pe butonul din această fereastră Anula(Open1.Execute = False), apoi îl informăm despre acest lucru și nu efectuăm nicio acțiune. Dacă utilizatorul a selectat un fișier, apoi copiați calea către acesta în câmpul de intrare corespunzător.

Să creăm un handler de evenimente similar pentru selectarea căii de destinație la copierea primului fișier (butonul Button3 corespunde câmpului unde):

apoi unde.Text:= Save1.FileName

else ShowMessage ("Nu ați selectat o locație pentru a salva fișierul!");

Aici se efectuează aceeași verificare ca și în cazul precedent. Calea selectată este apoi introdusă în câmpul de intrare corespunzător, astfel încât să poată fi ajustată dacă se dorește.

Acum să creăm un handler de evenimente OnClick similar pentru buton Recenzie, folosit pentru a selecta locația fișierului de șters:

apoi Del.Text:= Open1.FileName

else ShowMessage ("Fișierul nu a fost deschis!");

Butonul în sine Şterge execută următorul cod la clic:

procedura TForm1.Button6Click(Expeditor: obiect);

DeleteFile(Del.Text);//sterge fisierul

dacă nu FileExists(Del.Text)//verifică existența fișierului

apoi ShowMessage ("Fișier șters!");//afișează un mesaj

Mai întâi ștergem fișierul și apoi verificăm dacă acesta există pe disc după efectuarea operației de ștergere. Dacă nu există, atunci afișăm un mesaj care indică faptul că fișierul a fost șters cu succes. Acum puteți compila și rula programul. Aspect ferestre Lucrul cu fișiere prezentată în acțiune în Fig. 2.2.

Orez. 2.2. File Program de lucru în acțiune

Cod sursă modul complet

Codul complet al modulului de program Lucrul cu fișiere este prezentat în Lista 2.1.

Lista 2.1. Modulul program Lucrul cu fișiere

Ferestre, Mesaje, SysUtils, Variante, Clase, Grafică, Controale, Forme, Dialoguri, StdCtrls, ShellAPI, Gauges;

procedură Button1Click(Expeditor: TObject);

procedura Button2Click(Expeditor: TObject);

procedura Button3Click(Expeditor: TObject);

procedură Button5Click(Expeditor: TObject);

procedura Button4Click(Expeditor: TObject);

procedura Button6Click(Expeditor: TObject);

procedura trebuie; //declarația de procedură doit

f1, f2: fișier de octet; //lucrează cu primul și al doilea fișier

litter: octet; //pentru copierea octet cu octet

sizez: longint; //stochează dimensiunea fișierului

(I-) (dezactivează directiva care monitorizează erorile I/O)

//asociați variabila Fișier f1 cu primul fișier

//legați variabila de fișier f2 la al doilea fișier

Resetare(f1); //deschide primul fișier pentru citire

sizez:= Trunc(FileSize(f1)); //aflați dimensiunea fișierului

//Afișează dimensiunea fișierului pentru utilizator)

Label4.Caption:= IntToStr(sizez div 1024) + „Kb”;

(Creați un al doilea fișier sau suprascrieți-l dacă există deja)

în timp ce Eof(f1) nu începe //până când se ajunge la sfârșitul primului fișier

//citește un octet din primul fișier

// scrie un octet în al doilea fișier

CloseFile(f1);//închide primul fișier

CloseFile(f2); // închide al doilea fișier

dacă IORrezultat<>0 //Dacă apare o eroare I/O

apoi MessageDlg("Eroare la copierea fișierului!", mtError, , 0) //mesaj de eroare

(dacă nu au existat erori, atunci vom afișa o fereastră care indică finalizarea cu succes a copierii)

ShowMessage("Copiat cu succes!");

procedura TForm1.ButtonlClick(Expeditor: TObject);

procedura TForm1.Button2Click(Expeditor: TObject);

if Open1.Execute, atunci from.Text:= Open1.FileName

else ShowMessage("Fișierul nu a fost deschis");

procedura TForm1.Button3Click(Expeditor: TObject);

if Save1.Execute atunci unde.Text:= Save1.FileName

else ShowMessage(""Nu ați selectat o locație pentru a salva fișierul!");

procedura TForm1.Button5Click(Expeditor: TObject);

DeleteFile(from.Text); //sterge fisierul sursa

procedura TForm1.Button4Click(Expeditor: TObject);

dacă Open1.Execute, atunci del.Text:= Open1.FileName

else ShowMessage("Fișierul nu a fost selectat");

procedura TForm1.Button6Click(Expeditor: TObject);

DeleteFile(del.Text); //sterge fisierul

apoi //verificați existența fișierului

//afișează un mesaj despre ștergerea cu succes

ShowMessage("Fișier șters!");

⊚ Toate fișierele de proiect și fișier executabil ale programului considerat se află pe CD-ul furnizat cu cartea în folderul Chapter_02.

Acest articol se adresează începătorilor care doresc să învețe cum să lucreze cu fișiere în Delphi. Articolul discută operațiunile standard de I/O cu fișiere, greșeli tipiceși metode de prevenire a acestora.

În Delphi, un fișier este reprezentat ca o structură de date numită, adică. secvență de același tip de date. În linii mari, aceasta este o gamă uriașă, al cărei număr de elemente este practic nelimitat. Pentru a facilita lucrul cu fișierele din Delphi, fiecare dosar separat reprezintă o variabilă de fișier. Deoarece este o variabilă, trebuie declarată ca variabilă. Cu toate acestea, primul lucru.

Pasul 1 - Declararea unei variabile de fișier

O variabilă de fișier este în general declarată în secțiunea var astfel:

F: fișier de tip;

De exemplu:

F: Fișierul întregului;

Trebuie remarcat faptul că fișierele text sunt declarate ușor diferit:

Și, în general, fișierele text sunt „speciale”. Unele funcții funcționează numai cu fișiere text. De asemenea, puteți declara nu numai un fișier întreg, un fișier text sau un fișier de alt tip, ci și un fișier de tipul propriu sau înregistrare, plasând declarația de tip sau înregistrare deasupra declarației variabilei fișierului. De exemplu:

TDay = (LU, MAR, MI, JO, VIN, SAM, DUM);

F: Fișierul TDay;

Vă rugăm să rețineți că lungimea câmpurilor de șir din înregistrare trebuie să fie clar definită (Nume: șir)

Pasul 2 - Atribuirea și deschiderea unui fișier

După declararea unei variabile de fișier, trebuie să o asociați cu un fișier fizic de pe disc. Acest lucru se poate face folosind procedura AssignFile:

AssignFile(var F: File; FileName: String);

De exemplu:

var F: TextFile;

AssignFile(F, "text.txt");

După finalizarea procedurii, variabila de fișier F va fi asociată fișierului text.txt aflat în folderul programului. Și toate acțiunile efectuate cu variabila vor acționa asupra acestui fișier. Cu toate acestea, variabila poate fi eliberată pentru utilizare ulterioară cu un alt fișier utilizând procedura CloseFile, dar mai multe despre asta mai jos. Acum trebuie să deschideți fișierul, într-unul din mai multe moduri, în funcție de nevoile dvs. Puteți crea unul nou sau îl puteți suprascrie pe unul existent utilizând procedura Rewrite(F). Puteți deschide pentru scriere la sfârșitul fișierului folosind procedura Append(F). Și deschiderea fișierului pentru citire se realizează prin procedura de resetare.

Pasul 3 - Operații standard I/O cu fișiere

I/O sunt operațiuni de intrare/ieșire. Aici ne vom uita la scrierea datelor într-un fișier și citirea acestor date. Înregistrarea întâi. Puteți scrie o variabilă sau o constantă într-un fișier de tipul pentru care a fost declarat fișierul. De exemplu, dacă un fișier a fost declarat astfel F: File of Integer, atunci numai date de tip Integer pot fi scrise în el. Dacă încercați să scrieți date de alt tip, compilatorul va genera un mesaj de eroare. Scrierea într-un fișier se realizează prin procedurile Write(; P1; [...,Pn]) și WriteLn(; P1; [...,Pn]). Al doilea diferă de primul prin faptul că, după ce scrie parametrul, mută căruciorul pe o nouă linie, adică. următorul parametru va fi scris linie nouă. Iată un exemplu de utilizare a procedurilor:

var F: TextFile;

Str:= „Un text”;

WriteLn(F, Str);

Scrie(F, „aceasta va fi pe noul stoc”);

scrieți(F, "și aceasta este pe aceeași linie");

Datele sunt citite folosind procedurile Read(; V1; [...,Vn]) și ReadLn(; V1; [...,Vn]). Ele diferă prin faptul că, după ce parametrul este citit prin procedura ReadLn, căruciorul se mută pe o linie nouă, chiar dacă mai existau date. Iată un exemplu:

var F: TextFile;

ReadLn(F, Str2);//str2 va conține datele care vin după str

Read(F, Str3);//str3 va conține datele care se află pe noua linie după str2

Cred că nu este chiar atât de complicat.

Pasul 4 - Închiderea fișierului

Variabila fișierului trebuie eliberată după utilizare, altfel programul nu se va închide și va genera o eroare. De asemenea, eliberarea unei variabile de fișier va fi utilă atunci când trebuie să lucrați cu mai multe fișiere secvențial, iar după ce lucrați cu primul fișier, puteți elibera variabila și o puteți asocia cu un fișier nou. Procedura CloseFile(F: File) eliberează variabila fișier. Cred că nu este nevoie de un exemplu, pentru că... ea nu are caracteristici speciale.

Cred că va fi încă dificil pentru un începător să înțeleagă cum să lucreze cu fișiere fără exemple. Deci haideți să aruncăm o privire cel mai simplu exemplu un program care, prin apasarea unui buton, va solicita utilizatorului un nume de fișier și va înregistra conținutul TMemo. Și când apăsați un alt buton, programul va solicita din nou numele fișierului, va citi datele înregistrate de acolo și le va plasa în TMemo. Știu că scrierea și citirea în TMemo pot fi organizate folosind metode speciale. Dar acesta este doar un exemplu pentru articol. În general, aruncați un TMemo și două butoane pe formular. Schimbați primul handler de buton în acest formular:

procedura TForm1.Button1Click(Expeditor: TObject);

FileName: șir;

AssignFile(F, FileName);

pentru i:= 0 la Memo1.Lines.Count do

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

Acest buton va salva un fișier text. Deci, în secțiunea var am declarat trei variabile locale: F de tip TextFile este o variabilă de fișier pentru fișierele text; FileName de tip String va servi pentru a stoca numele fișierului; Și i este de tip Integer - pentru bucle. În prima linie cer utilizatorului numele fișierului. În al doilea, asociez o variabilă de fișier cu un fișier fizic de pe disc. Linia Rewrite(F) creează un fișier nou sau suprascrie unul existent. Pentru ca datele să nu fie înlocuite, ci adăugate la sfârșitul fișierului, această linie trebuie înlocuită cu Append(F). Urmează o buclă de la 0 la numărul tuturor liniilor din Memo1. În buclă, conținutul tuturor liniilor Memo1 este scris într-un fișier. Vă rugăm să rețineți că folosesc WriteLn pentru a scrie linie nouă. Dacă aș folosi Write, atunci toate liniile Memo1 din fișier s-ar transforma într-una singură.

Al doilea handler de buton ar trebui să arate cam așa:

procedura TForm1.Button2Click(Expeditor: TObject);

FileName, tmp: String;

FileName:= InputBox(„Nume fișier”, „Introduceți numele fișierului”, „default.txt”);

AssignFile(F, FileName);

în timp ce nu EOF(f) face

Memo1.Lines.Add(tmp);

Alocarea variabilelor locale în această procedură este similară cu cele anterioare. Prima și a doua linie sunt similare cu liniile de la primul handler de butoane. Reset(F) - Deschid fișierul pentru citire folosind procedura Reset. Apoi, se lansează o buclă peste întregul fișier (în timp ce EOF(F) nu o face). Funcția EOF(F: Fișier) returnează true când se ajunge la sfârșitul fișierului. Bucla citește o linie din fișier în variabila tmp și o adaugă la Memo1. Asta e tot, cred că e destul de simplu. Cu toate acestea, este ușor să păcăliți programul pentru a provoca o excepție. De exemplu, atunci când citește un fișier, utilizatorul poate specifica numele unui fișier inexistent. Apoi va apărea o eroare. În continuare vom vorbi despre modalități de a proteja un program de excepții

Metoda 1 - Cea mai simplă

Desigur, cel mai simplu, dar suficient mod eficient protecțiile pot fi organizate folosind blocuri imbricate try - except și try - finally. Știți că, dacă apare o excepție la executarea unei instrucțiuni în corpul unui bloc try - except, atunci execuția instrucțiunilor ulterioare se oprește și se execută ceea ce este între except - end. Dar dacă apare o excepție și apoi se găsește CloseFile(F), atunci această procedură nu este executată și programul nu va putea funcționa corect și nu va putea termina. Soluția la această problemă este să folosiți imbricat try - cu excepția și try - în final. Iată un exemplu

MessageDlg("Eroare de lucru cu fișierul", mtError, , 0);

Dar această metodă poate să nu funcționeze dacă a existat o încercare de a deschide un fișier inexistent (va apărea o excepție la executarea CloseFile(F)).

Metoda 2 - Eficient

Se știe că programul în sine se ocupă de gestionarea excepțiilor. Dar ea nu o face întotdeauna bine. De aceea cea mai buna solutie Ar fi bine să controlați momentul în care fișierul este deschis. Pentru a face acest lucru, trebuie mai întâi să dezactivați gestionarea automată a excepțiilor cu directiva (I-). Și îl puteți porni astfel: (I+). Apoi verificați valoarea funcției IOResult. Dacă fișierul este deschis cu succes, returnează 0. Iată un exemplu:

dacă IORrezultat<>0 atunci

MessageDlg("Fișierul "+PChar(FileName)+ " nu există", mtError, , 0);

IEȘIRE; //nu pot continua

Inserați toate acestea în procedura de citire a fișierului (în exemplul de mai sus) în loc de linia Reset(F). De asemenea, vă puteți asigura împotriva defecțiunilor inserând această construcție în procedura de salvare a fișierului în loc de linia de rescriere.