Tund 15. Töö failidega

Selles õppetükis vaatleme väga oluline teema programmeerimises - failidega töötamine.
Peaaegu igas programmis peate faile kopeerima, avama, muutma, salvestama ja mõnikord ka kustutama.

Nagu teate, on failidel erinevaid formaate ja kohaldada neile erinevaid programme töötlemiseks. Näiteks BMP pildifailid, tekst TXT-failid jne. Failidel on erinevad nimed ja konkreetne laiend, millel on MS-DOS keskkond maksimaalselt kolm tähemärki. Kui failil on RAR-laiend, siis kasutaja ja operatsioonisüsteemi teab, et see on arhiveerija, ja Windosw kasutab punktis määratletud tööriistu spetsiaalne sektsioon register

Failide kopeerimine

Funktsiooni CopyFile kasutatakse failide kopeerimiseks. Selle formaat on järgmine:

CopyFile(allika_fail, kirjutamisfail, ülekirjutamise_lipp);

kus: Source_file – täis tee ja kopeeritava faili nimi;

Write_file – selle faili täielik tee ja nimi, kuhu lähtefail kopeeritakse;

Overwrite_flag – kas fail kirjutatakse üle või mitte, kui see on juba olemas (tõene - ei ole, false - see kirjutatakse üle).

CopyFile on funktsioon, mis tagastab lipu, kas kopeerimistoiming õnnestus või mitte.

Näiteks järgmine rida:

kui mitte CopyFile("c:\command.com","c:\1.com",true) siis ShowMessage("Kopeerimise viga");

kopeerib faili command.com faili 1.com ainult siis, kui viimast pole olemas, vastasel juhul kuvatakse kopeerimise veateade.

Failide teisaldamine

Funktsiooni MoveFile kasutatakse failide teisaldamiseks. Tal on järgmine formaat:

MoveFile(allika_fail, kirjutamisfail);

Selle parameetrid on sarnased ülaltoodud käsuga, välja arvatud ümberkirjutamise lipu puudumine.

kui mitte MoveFile("c:\1.com","c:\2.com"), siis ShowMessage("Teisaldamisviga");

Failide ümbernimetamine

Funktsioon RenameFile

kui mitte RenameFile("c:\2.com","c:\3.com"), siis ShowMessage("Ümbernimetamise viga");

Kõigil ülaltoodud käskudel on algus- ja lõplik fail on PChar tüüpi. See stringi tüüp null-lõpetatud. Võib-olla olete sellest stringi andmevormingust varem kuulnud. Sellisesse muutujasse saab stringi panna väga. Selle suurust piirab nullbaidi olemasolu lõpus. Teoreetiliselt võib sellisel muutujal olla lõpmatu suurus. Praktikas piirab seda programmi jaoks eraldatud mälu suurus (2 GB).

Teisenda normaalseks string muutuja, tüüp String PCharis toodetakse funktsiooniga:

PChar(String_muutuja).

Samas võistkondadele failitoimingud stringide ühendamine on võimalik. Näiteks:

protseduur Tvorm1.Button1Click(Saatja: TObject);

Var InDir,OutDir:String; // stringi muutujate deklaratsioon

alustada

InDir:="c:\1\"; // kataloog lähtefailid

OutDir:="c:\2\"; // kirjutatavate failide kataloog

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

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

lõpp;

Siin on kahe stringimuutuja ühendamise operatsioon.

Selle protseduuri tulemusena kopeeritakse failid c:\1\1.txt ja c:\1\2.txt kataloogi c:\2. Failid kopeeritakse samade nimede all.

Failide kustutamine

Funktsioon DeleteFile

kui mitte DeleteFile("c:\3.com"), siis ShowMessage("Kustuta viga");

Töö tekstifailidega. Tekstifailist lugemine

Eelmistes tundides tegime memo komponendis tekstifaili laadimise ja kirjutamise protsessi järgmiselt:

Memo1.Lines.SaveToFile(Failinimi);

// salvesta

Kõik see on tänu Liinide varale, mis liine salvestab.
Järgmine tekstifaili töötlemise näide on väga sarnane Pascalis olevale. Teadlikud inimesed

võib erinevust tunda, kuna on mõningaid erinevusi.

protseduurTvorm1.Button1Click(Saatja: TOobject);

Varf:Tekstifail; // faili muutuja deklaratsioon st: String

alustada

; // stringi muutuja

AssignFile(f,"c:\1.txt"); // failinime sidumine failimuutujaga

($I-) // I/O veakontrolli keelamine

Lähtesta(f); // avage fail lugemiseks

($I+) // lubab I/O vigade jälgimist<>0 ifIOResult siis // kui on avamise viga

alustada

, See

ShowMessage("Viga faili C:\1.TXT avamisel");

Väljumine; // väljub protseduurist, kui faili avamisel ilmneb tõrge;

lõppu Kuigi mitte EOF(f) teha // veel mitte faili lõpp

alustada

tee silmus:

Väljumine; // väljub protseduurist, kui faili avamisel ilmneb tõrge;

ShowMessage(st); // väljastab kasutajale stringi

lõpp;

CloseFile(f); // sulgege fail

Lubage mul kommenteerida selle näite mõnda rida. Käsk AssignFile seob failitee stringi failimuutujaga. Kõik edasised toimingud failimuutujaga viiakse automaatselt läbi määratud fail

($I-) ja ($I+) on kompilaatori käsud I/O veakontrolli keelamiseks ja lubamiseks. Sellisel juhul, kui faili c:\1.txt avamise katse ebaõnnestub (fail puudub või on mõne teise programmi jaoks avatud kirjutamiseks), ei tekita meie programm hädaabitõrget ja jätkab selle protseduuri täitmist. See omadus on kasulik kõigi käitlemiseks võimalikud juhtumid

programmi töös.

IOResult on muutuja, mis salvestab viimase I/O operatsiooni veakoodi. Kui see on null, on viimane toiming edukalt lõpule viidud.

EOF(File) – funktsioon, mis tagastab faili lõpu märgi. Need. see näitab, kas avatud faili lõpp on saavutatud või mitte.

ReadLn(File, Variable) – protseduur muutuja failist lugemiseks. Erinevalt käsust Read loeb see rida, mis lõpeb reavahetuse märgiga koodide 13 ja 10 all (klahv Enter).

CloseFile(File) – protseduur varem avatud faili sulgemiseks.

Töö tekstifailidega. Tekstifaili kirjutamine

Vaatame näidet:

protseduur Tvorm1.Button1Click(Saatja: TObject);

Var f:Tekstifail; // kursor tekstifailile

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

// nime sidumine muutujaga<>0 Lisa(f);// avage lisamiseks fail

kui IORsult siis //

// nime sidumine muutujaga<>kui avamisel ilmneb tõrge (näiteks faili pole)

Rewrite(f);

// luua

uus fail

0 siis // faili loomise viga

ShowMessage("Viga faili C:\1.TXT loomisel");

WriteLn(f"Tere");

// kirjutage faili reavahetusmärkidega string

CloseFile(f);// sulgege fail

Protseduur Append avab faili kirjutamiseks ja seab kirjutamisosuti faili lõppu, s.t. kõik failile lisatud read kirjutatakse faili lõppu. Meie puhul ei pruugi 1.txt faili päris alguses kettal olla, mistõttu faili lisamiseks avamise käsk põhjustab tõrke. Sel juhul käivitatakse meie enda veakontroll ja täidetakse faili loomise käsk. Mittetekstiandmete kirjutamine ja lugemine failist Vaatleme näidet, kus programm salvestab väljumisel oma suuruse ja akna asukoha ekraanil faili ning hilisemal käivitamisel taastab oleku, mis tal oli väljumisel. Programm koosneb kahest protseduurist OnShow ja OnClose programmi Form1 akna jaoks. menetlust

TForm1.FormShow(Saatja: TObject);

alustada

Var

f:

faili

kohta

Täisarv;// faili muutuja, tippige täisarv<>0 ifIOResult I:Täisarv; // täisarv muutuja

AssignFile(f,"pos.ini");

($I-)

Vorm1.Vasak:=i; // akna vasakpoolne asend

($I-)

Vorm1.Laius:=i; // akna laius

($I-)

Vorm1.Kõrgus:=i; // akna kõrgus

CloseFile(f);

Väljumine; // väljub protseduurist, kui faili avamisel ilmneb tõrge;

CloseFile(f); TForm1.FormClose(Saatja: TObject; var Tegevus: TCloseAction);

Protseduur Append avab faili kirjutamiseks ja seab kirjutamisosuti faili lõppu, s.t. kõik failile lisatud read kirjutatakse faili lõppu. Meie puhul ei pruugi 1.txt faili päris alguses kettal olla, mistõttu faili lisamiseks avamise käsk põhjustab tõrke. Sel juhul käivitatakse meie enda veakontroll ja täidetakse faili loomise käsk. Mittetekstiandmete kirjutamine ja lugemine failist Vaatleme näidet, kus programm salvestab väljumisel oma suuruse ja akna asukoha ekraanil faili ning hilisemal käivitamisel taastab oleku, mis tal oli väljumisel. Programm koosneb kahest protseduurist OnShow ja OnClose programmi Form1 akna jaoks. Täisarv;

Hoolimata asjaolust, et Delphis on mitu meetodit, mis võimaldavad teil failidega suhelda, nõuab töötehnoloogia teatud toimingute järjekorda järgimist:

1. Fail peab olema avatud. Teised rakendused ei tohiks failiga töötamist segada, süsteem jälgib seda hoolikalt. Samal ajal määrab süsteem, millistel eesmärkidel fail avatakse. Siin on mitu võimalust: lugeda või teha muudatusi.

Pärast dokumendi loomist või avamist saab süsteem spetsiaalse identifikaatori, mida kasutatakse kõigis järgnevates töötlemistoimingutes sellele failile viitajana.

3. Pärast kõike vajalikud toimingud käivitatakse ja fail kirjutatakse, dokument suletakse. Sellest hetkest alates muutub see teistele rakendustele täiesti piiranguteta kättesaadavaks. Tasub teada, et faili sulgemine tagab kõigi tehtud muudatuste salvestamise. Seega sissepääs Delphi fail nõutavad andmed edukalt täidetud.

Kui see ülesanne tundub üsna keeruline, siis võib abi otsida professionaalidelt, kes lisaks Delphile teavad kõike vajalikku Linuxi haldusest.

Delphi tekstifaili kirjutamine

Delphis esitatakse faili sama tüüpi andmete jadana. Teisisõnu, sellest piisab suur massiiv, mille suurus on praktiliselt piiramatu. Delphi tekstifaili kirjutamise hõlbustamiseks esitatakse iga dokument failimuutujana.

Töötamiseks tekstidokumendid kasutatakse TextFile tüüpi, mis on kirjutatud järgmiselt:

Muutuja: Type TextFile;
Failile juurdepääsu saamiseks kasutage protseduuri AssignFile(). Kui failile juurdepääs on saadud, saab selle protseduuride abil avada Lähtesta, kirjuta ümber. Täpsemalt protseduur Lähtesta() avab varem loodud dokumendi ja protseduuri Kirjuta ümber () võimaldab luua uue faili või kustutada olemasoleva. Fail suletakse spetsiaalse CloseFile protseduuri abil. Delphi tekstifaili saate kirjutada, kasutades selliseid protseduure nagu Write või WriteLn.

Salvestamine excelis

Juhul, kui on vaja sisse salvestada Excel Delphi, peate kasutama teatud toimingute algoritmi. Esmalt luuakse variandi massiiv, seejärel sisestatakse sellesse massiivi andmed ja ühe toiminguga kirjutatakse kogu see massiiv exceli fail. Väärib märkimist, et Excelis salvestamine on selles väga asjakohane viimasel ajal, kuna seda redaktorit kasutatakse laialdaselt erinevate aruannete ja trükitud vormide arendamiseks.

See artikkel on suunatud algajatele, kes soovivad õppida Delphis failidega töötamist. Artiklis käsitletakse standardseid I/O toiminguid failidega, tüüpilised vead ja nende ennetamise meetodeid.

Delphis on fail kujutatud nimelise andmestruktuurina, st. sama tüüpi andmete jada. Jämedalt öeldes on see tohutu massiiv, mille elementide arv on praktiliselt piiramatu. Delphis failidega töötamise hõlbustamiseks kasutage iga eraldi fail tähistab failimuutujat. Kuna see on muutuja, tuleb see deklareerida muutujana. Siiski kõigepealt kõigepealt.

1. samm – failimuutuja deklareerimine

Faili muutuja sisse üldine vaade deklareeris jaotises var midagi sellist:

F: tüüpi fail;

Näiteks:

F: täisarvu fail;

Tuleb märkida, et tekstifailid deklareeritakse veidi erinevalt:

Ja üldiselt on tekstifailid "erilised". Mõned funktsioonid töötavad ainult tekstifailidega. Samuti saate deklareerida mitte ainult täisarvufaili, tekstifaili või mõnda muud tüüpi faili, vaid ka oma tüüpi faili või kirjet, asetades tüübi või kirje deklaratsiooni failimuutuja deklaratsiooni kohale. Näiteks:

TPäev = (ES, TE, K, N, R, R, L, P);

F: TDay fail;

F: TDay fail;

Pange tähele, et kirje stringiväljade pikkus peab olema selgelt määratletud (nimi: string)

2. samm – faili määramine ja avamine

Pärast failimuutuja deklareerimist peate selle siduma füüsiline fail kettal. Seda saab teha protseduuri AssignFile abil:

AssignFile(var F: fail; failinimi: string);

Näiteks:

var F: TextFile;

AssignFile(F, "text.txt");

Pärast protseduuri lõpetamist seotakse failimuutuja F programmikaustas asuva failiga text.txt. Ja kõik muutujaga tehtud toimingud mõjutavad seda faili. Kuid muutuja saab vabastada edasiseks kasutamiseks mõne teise failiga, kasutades protseduuri CloseFile, kuid sellest lähemalt allpool. Nüüd peate faili avama ühel mitmel viisil, olenevalt teie vajadustest. Rewrite(F) protseduuri abil saate luua uue või olemasoleva üle kirjutada. Saate avada faili lõpus kirjutamiseks, kasutades protseduuri Lisa(F). Ja faili avamine lugemiseks toimub lähtestamise protseduuri abil.

3. samm – standardsed I/O toimingud failidega

I/O on sisend/väljundoperatsioonid. Siin vaatleme andmete faili kirjutamist ja nende lugemist. Esmalt salvestamine. Saate kirjutada muutuja või konstandi faili, mille tüüp on fail deklareeritud. Näiteks kui fail deklareeriti järgmiselt: F: File of Integer, siis saab sinna kirjutada ainult Integer tüüpi andmeid. Kui proovite kirjutada teist tüüpi andmeid, genereerib kompilaator veateate. Faili kirjutamine toimub protseduuride Write(; P1; [...,Pn]) ja WriteLn(; P1; [...,Pn]) abil. Teine erineb esimesest selle poolest, et peale parameetri kirjutamist liigutab kelgu uuele reale, s.t. järgmine parameeter kirjutatakse uuele reale. Siin on näide protseduuride kasutamisest:

var F: TextFile;

Str:= "Mõned tekstid";

WriteLn(F, Str);

Write(F, "see on uuel aktsial");

write(F, "ja see on samal real");

Andmete lugemiseks kasutatakse protseduure Read(; V1; [...,Vn]) ja ReadLn(; V1; [...,Vn]). Need erinevad selle poolest, et pärast parameetri lugemist protseduuriga ReadLn liigub kelk uuele reale, isegi kui andmeid oli veel. Siin on näide:

var F: TextFile;

ReadLn(F, Str2);//str2 sisaldab str-i järel tulevaid andmeid

Read(F, Str3);//str3 sisaldab andmeid, mis on uuel real pärast str2

Ma arvan, et see pole kõik nii keeruline.

4. samm – faili sulgemine

Faili muutuja tuleb pärast kasutamist vabastada, vastasel juhul programm ei sulgu ja tekitab vea. Samuti on failimuutuja vabastamine kasulik, kui peate töötama järjestikku mitme failiga ning pärast esimese failiga töötamist saate muutuja vabastada ja uue failiga siduda. Protseduur CloseFile(F: File) vabastab failimuutuja. Ma arvan, et näidet pole vaja, sest... tal pole erilisi jooni.

Ma arvan, et algajal on ilma näideteta failidega töötamisest siiski raske aru saada. Nii et vaatame lihtsaim näide programm, mis ühe nupuvajutusega küsib kasutajalt failinime ja salvestab TMemo sisu. Ja kui vajutate teist nuppu, küsib programm uuesti faili nime, loeb sealt salvestatud andmed ja asetab need TMemosse. Tean, et TMemos kirjutamist ja lugemist saab korraldada spetsiaalsete meetoditega. Kuid see on vaid näide artikli jaoks. Üldiselt viska vormile üks TMemo ja kaks nuppu. Muutke esimese nupu töötleja sellele vormile:

protseduur Tvorm1.Button1Click(Saatja: TObject);

Failinimi: String;

Määra fail(F, failinimi);

jaoks i:= 0 kuni Memo1.Lines.Count teha

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

See nupp salvestab tekstifaili. Niisiis deklareerisin jaotises var kolm kohalikku muutujat: F tüüpi TextFile on tekstifailide failimuutuja; Failinimi, mille tüüp on String, salvestab failinime; Ja i on tüüp Integer – silmuste jaoks. Esimesel real küsin kasutajalt faili nime. Teises seon failimuutuja kettal oleva füüsilise failiga. Rewrite(F) loob uue faili või kirjutab olemasoleva üle. Et andmeid ei asendataks, vaid lisataks faili lõppu, tuleb see rida asendada käsuga Append(F). Järgmiseks tuleb tsükkel nullist Memo1 kõigi ridade arvuni. Silmuses kirjutatakse kõigi Memo1 ridade sisu faili järjekorras. Pange tähele, et ma kasutan kirjutamiseks WriteLni uus rida. Kui kasutaksin Write'i, muutuksid kõik failis olevad Memo1 read üheks.

Teise nupu töötleja peaks välja nägema umbes selline:

protseduur Tvorm1.Button2Click(Saatja: TObject);

Failinimi, tmp: String;

FileName:= InputBox("Faili nimi", "Sisesta failinimi", "vaikimisi.txt");

Määra fail(F, failinimi);

samas kui seda ei tee EOF(f).

Memo1.Read.Lisa(tmp);

Kohalike muutujate määramine selles protseduuris on sarnane eelmistele. Esimene ja teine ​​rida on sarnased esimese nupukäsitleja ridadega. Reset(F) – avan faili lugemiseks, kasutades Reset protseduuri. Järgmisena käivitatakse kogu faili silmus (kuigi EOF(F) seda ei tee). Funktsioon EOF(F: File) tagastab tõene, kui faili lõpp on saavutatud. Silmus loeb failist ühe rea muutujasse tmp ja lisab selle Memo1-sse. See on kõik, ma arvan, et see on üsna lihtne. Programmi on aga lihtne petta, et see põhjustaks erandi. Näiteks faili lugemisel saab kasutaja määrata nime mitte olemasolevat faili. Siis tekib tõrge. Järgmisena räägime viisidest, kuidas kaitsta programmi erandite eest

1. meetod – kõige lihtsam

Muidugi kõige lihtsam, aga piisav tõhus viis kaitseid saab korraldada pesastatud try - välja arvatud ja try - lõpuks blokkide abil. Teate küll, et kui käskluse täitmisel try -välja arvatud plokk - tekib erand, siis edasiste käskude täitmine peatub ja täidetakse see, mis jääb erandi - end vahele. Kuid kui ilmneb erand ja CloseFile(F) leitakse, siis seda protseduuri ei käivitata ja programm ei saa korralikult töötada ega lõpetada. Selle probleemi lahendus on kasutada pesastatud proovi – välja arvatud ja proovi – lõpuks. Siin on näide

MessageDlg("Viga failiga töötamisel", mtError, , 0);

Kuid see meetod ei pruugi töötada, kui üritati avada olematut faili (CloseFile(F) käivitamisel ilmneb erand).

2. meetod – tõhus

On teada, et programm ise hoolitseb erandite käsitlemise eest. Kuid ta ei tee seda alati õigesti. Sellepärast parim lahendus Tore oleks kontrollida faili avamise hetke. Selleks tuleb esmalt keelata automaatne erandite käsitlemine (I-) direktiiviga. Ja saate selle sisse lülitada järgmiselt: (I+). Seejärel kontrollige funktsiooni IOResult väärtust. Kui fail avatakse edukalt, tagastab see 0. Siin on näide:

kui IORsult<>0 siis

MessageDlg("Faili "+PChar(Failinimi)+ " ei eksisteeri", mtError, , 0);

VÄLJU; //ei saa jätkata

Sisestage see kõik faili lugemisprotseduuri (ülaltoodud näites) rea Reset(F) asemel. Samuti saate rikete vastu kindlustada, kui sisestate selle konstruktsiooni faili salvestamise protseduuri rea Rewrite asemel.

Nimega mäluala sisse lülitatud välist meediat(ketas) kutsutakse faili. Igal failil on Nimi. Teave, mis on failis salvestatud, esindab sama tüüpi elementide komplekti. Suurus faili piirab tavaliselt ainult selle seadme maht, kuhu see salvestatakse, mis võimaldab töödelda suuri teabehulki.

Väljakuulutamise meetod fail sõltub selle tüübist. Faile on kolme tüüpi:

tekst;

trükitud;

trükkimata.

Tekstifail, koosneb mis tahes märkide jadast. Märgid moodustavad ridu, millest igaüks lõpeb rea lõpu märgiga. Faili enda lõppu tähistab sümbol "faili lõpp". Teabe kirjutamisel tekstifaili teisendatakse kõik andmed märgitüübiks ja salvestatakse sellel kujul. Tekstifaili saate vaadata mis tahes abil tekstiredaktor.

Tekstifaili kirjeldus:

muutuja_nimi: tekstifail;

Trükitud fail koosneb sama tüüpi elementidest, mille arv ei ole ette määratud ja võib olla ükskõik milline. See lõpeb ka sümboliga "faili lõpp". Trükitud failis olevad andmed salvestatakse kahendkoodid ja neid ei vaadata tekstiredaktorid. Selliste failide deklaratsioon näeb välja järgmine:

muutuja_nimi: faili tüüp;

IN tippimata failid teave loetakse ja kirjutatakse vormile plokid teatud suurusega, võivad nad salvestada mis tahes tüüpi ja struktuuriga andmeid. Trükimata faili kirjeldus:

muutuja_nimi: fail;

Sest juurdepääs failidele kasutage spetsiaalset faili muutuja.

Näiteks:

c:täisarvu fail;

Sest side faili muutuja kettal oleva failiga, kasutage protseduuri:

AssignFile(muutuja, failinimi);

siin on muutuja mis tahes muutuja nimi failitüüp, faili_nimi on märgistring, mis sisaldab täisnimi fail (kui faili asukohta pole määratud, eeldatakse, et see asub praegune kataloog).

Näiteks:

S:='text.txt';

assign(f,'d:\tp\tmp\abc.dat');

Sest olemasoleva faili avamine kasutage protseduuri:

Reset(faili_muutuja);

Pärast faili avamist on selle esimene komponent saadaval.

Uue faili loomiseks või olemasolevast teabe kustutamiseks toimige järgmiselt.

Rewrite(faili_muutuja);

Pärast hukkamist erinevaid operatsioone fail peaks olema suletud. Selleks kasutage protseduuri

CloseFile(faili_muutuja);

Andmete salvestamine tekstifaili viiakse läbi protseduuride abil

Write(muutuja, avaldiste_loend);

Writeln(muutuja, avaldiste_loend);

kus avaldise_loend on märk, täisarv, reaalarv, string või tõeväärtuslikud tüübid, mis kirjutatakse failimuutujaga seotud faili.

Writelni protseduur lisab iga rea ​​lõppu realõpetaja.

NÄIDE. Alamprogramm, mis loob kettal D faili abc.txt ja kirjutab sinna korrutustabeli.

var f:Tekstifail; i,j:bait;

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

i jaoks:=2 kuni 9 teha

j jaoks:= 2 kuni 9 teha

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

Andmete lugemine failist viiakse läbi järjestikku faili algusest protseduuriga

Readln(muutuja, muutujate_loend);

siin loetleb muutujate_loend muutujad, millesse failimuutujaga seotud failist loetud andmed kirjutatakse.

Protseduur Readln liigub pärast failist järgmise elemendi lugemist järgmisele reale.

Järgmise alamprogrammi kutsumine toob kaasa faili teksti, mis kuvatakse redigeerimisaknas vormile D:\abc.txt:

protseduur Tvorm1.Button1Click(Saatja: TObject);

a:string; i:täisarv;

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

i jaoks:=1 kuni 8 teha

Memo1.Lines.Add(a);

Kohaldatav ka trükitud failide puhul lugemisprotseduurid Ja rekordid

Read(muutuja, muutujate loend);

Write(muutuja, avaldiste_loend);

ainult kirjutamis- ja lugemisavaldisetüübid peavad vastama deklareeritud failitüübile. Writeln ja Readln protseduurid ei kehti trükitud failide puhul.

Sest trükitud failis liikumine kasutage protseduuri:

Seek(muutuja, arv);

See protseduur võimaldab teil navigeerida elemendi juurde määratud number, see tähendab, et see viib läbi otsene juurdepääs failikomponentidele. Otsese juurdepääsu korral on failikomponendid nummerdatud vahemikus 0 kuni n-1, kus n on komponentide arv failis.

Tüübitud faili komponentidele otse juurdepääsuks saate kasutada ka järgmisi funktsioone.

fileize(muutuja) – tagastab reaalsete komponentide arvu ava fail seotud faili_muutujaga (for tühi fail funktsioon tagastab 0);

filepos(muutuja) – tagastab failimuutujaga seotud avatud faili praeguse asukoha väärtuse (kui fail on just avatud, tagastab funktsioon nulli; pärast failist viimase komponendi lugemist vastab funktsiooni väärtus failisuuruse väärtus, mis näitab, et faili lõpp on saavutatud).

Otsimise protseduur ning failisuuruse ja filepos funktsioonid tekstifailidega ei tööta. Järgmised rutiinid töötavad nii trükitud kui ka tekstifailidega.

Nimeta ümber (muutuja, failinimi)

nimetab faili muutujaga seotud suletud faili ümber vastavalt failinime real määratud nimele;

Erase(muutuja) – kustutab suletud fail, mis on seotud failimuutujaga;

Eof(muutuja) hindab tõeseks, kui faili_muutujaga seotud faili lõpp on saavutatud, muul juhul väär;

NÄIDE. Allolev alamprogramm töötab nii. Avab päris faili d:\abc.dat ja sinna on sisse kirjutatud teatud summa reaalarvud, arvutatakse valemiga. Loodud faili pole võimalik vaadata, kuna selles sisalduv teave on esitatud binaarkoodides.

protseduur Tvorm1.Button1Click(Saatja: TObject);

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

n:=StrToInt(Redigeeri1.Tekst);

i:=1 kuni n teha

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

Et tagada faili kirjutamine d:\abc.datõnnestus, kuvame selle väärtused redigeerimisaknas:

protseduur Tvorm1.Button1Click(Saatja: TObject);

f1: tegelik fail;

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

samas kui eof (f1) seda ei tee

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

ÜLESANNE. Plaadil E on täisarvude fail abc.int, vahetage selle maksimaalsed ja minimaalsed elemendid.

Järgmine programm töötab nii. Faili komponendid loetakse massiiviks. Massiivi elemendid kuvatakse väljal Memo1. Seejärel otsitakse massiivi miinimum- ja maksimumelemente ning nende indekseid. Maksimaalne ja minimaalne komponent kirjutatakse faili ümber vastavatesse kohtadesse.

Lõpuks kuvatakse teisendatud faili elemendid väljal Memo2.

protseduur Tvorm1.Button1Click(Saatja: TObject);

f:täisarvu fail;

a:täisarvude massiiv;

i,nmax,nmin:bait; max,min:täisarv;

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

i:=0 puhul failisuurus(f)-1 teha

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

max:=a; nmax:=0;

min:=a; nmin:=0;

i:=1 puhul failisuurus(f)-1 teha

kui a[i]>max siis

kui a[i]

i:=0 puhul failisuurus(f)-1 teha

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

Vaatame üksikasjalikult, kuidas faile kopeerida, kustutada ja ümber nimetada. Õpime lugema ja kirjutama teavet trükitud failidesse.

Failide kopeerimine kasutades .

Selleks peame kutsuma ainult ühe funktsiooni, mis konkreetselt faile kopeerib. See on funktsioon CopyFile(). Sellel on kolm parameetrit, millest kaks on nõutavad. Siin on täielik süntaks.
CopyFile("algfaili tee","tee, kuhu kopeerida", kas kirjutada üle või mitte)

Näide: CopyFile("D:sekretBD.txt","C: ame.txt", true);

Esimeses parameetris saate määrata mitte ainult faili täieliku tee. Kui määrame näiteks tee “sekretBD.txt”, siis meie programm otsib seda faili oma kataloogist. Nimi ja luba tuleb täpselt määrata nii, nagu need faili jaoks on, vastasel juhul ei leia programm faili lihtsalt üles.
Teises parameetris saate määrata ka suhtelise tee ja seal saate määrata faili nime ja laiendi, nagu soovite. Need. Seda funktsiooni kasutades saate teha ka ümbernimetamist.
Kolmas parameeter vastutab faili ülekirjutamise eest. Kui määrame tõese, siis faili üle ei kirjutata ja kui Väär, siis programm kirjutab faili üle.

Failide ümbernimetamine kasutades

Funktsioon RenameFile() vastutab failide ümbernimetamise eest. Sellel on 2 parameetrit. Siin on selle täielik süntaks
RenameFile("tee failini","uus nimi");
Ausalt öeldes pole ma selle funktsiooni süntaksiga eriti rahul. Selles peate mõlemas parameetris määrama ka täieliku tee. Need. kui me näiteks kirjutame nii

RenameFile("C:2.txt","3.txt");

Seejärel kopeerib see faili programmi kataloogi. Need. Selgub, et see võib olla ka koopia. See on natuke imelik.

Failide kustutamine kasutades

Noh, siin on kõik üsna lihtne. Funktsiooni, mida saab kasutada faili kustutamiseks, nimetatakse järgmiselt:

DeleteFile("C:minuprofiil.txt");

Ainus asi on see, et see ei kustuta faili alati 100%. Kui fail on kaitstud, ei saa ta seda kustutada.

Sisestatud failidega töötamine

Mis on trükitud fail? See on kindla struktuuriga fail. Tavaliselt koosneb see struktuur kirjetest ja baastüüpidest. Üldiselt on oluline, et tüübil oleks teada kindel suurus, seega ei saa stringitüüpi kasutada, vaid tuleb teha järgmiselt: String[N].
Kõigepealt peame deklareerima muutuja, kuhu faili andmed salvestatakse. Seda tehakse järgmiselt:

Var f: fail of<Тип>
Näiteks f: stringi fail;

Seejärel peame failiga ühenduse looma. Selleks on käsk AssignFile. Helistamiseks peate määrama kaks parameetrit, see on ülaltoodud muutuja ja faili tee. Näiteks

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

Nüüd tuleb fail avada. Seda saab avada kahel viisil: uuesti lihvimisega või ilma. Ümberkirjutamise meetod avab faili pärast selle esmakordset loomist. Need. kui fail ei asu meie määratud teel, loob see selle. Kui selline fail oli juba olemas, siis see kustutatakse ja luuakse uuesti puhas fail. Lähtestamismeetod avab faili ja asetab kursori faili algusesse. Kuid see meetod on ohtlik, sest kui ühenduses määratud faili pole olemas, jookseb programm veaga kokku. Seega, et funktsiooni Lähtesta õigesti kasutada, peate kompilaatoril käskima vead keelata. Seda määrab käskkiri ($I-) st. Lähtestamisfunktsiooni täielik süntaks oleks järgmine:

($I-)
Lähtesta(f);
($ I+)

Pärast seda peate kontrollima, kas fail avati või mitte. Seda saab teha funktsiooni IOResult abil. Kui see pole null, siis on kõik edukas.
Täielik süntaks:

($I-)
Lähtesta(f);
($ I+)
Kui IOtulemus<>0 siis<ваш код>

Funktsioon FileExists aitab teil ka kontrollida. See peab näitama faili tee.
Faili lugemiseks kasutage funktsiooni Read(), mis määrab kaks parameetrit: faili muutuja ja kirje tüüp, meie puhul on see string. Süntaks:

Faili kirjutamiseks kasutage funktsiooni Write(), mis määrab samad kaks parameetrit: faili muutuja ja kirje tüüp, meie puhul on see string. Süntaks:

Kuigi eof(f) seda ei tee
Read(f,String);

Seal on ka seek funktsioon, millega saame minna meid huvitava plaadi juurde. Näiteks peame pääsema juurde kirjele 20 ja teeme järgmist:

Samuti on olemas kärbimise funktsioon, millega saame kustutada faili kõik kirjed, alustades kursori asukohast. Positsiooni saab määrata otsingu funktsiooni abil, kes aru ei saanud.

Pärast kõigi toimingute sooritamist failiga peate selle sulgema funktsiooni CloseFile(f) abil;
See on kõik. Sellega õppetund lõpeb. Kohtumiseni saidil!