ഫയലുകൾ എങ്ങനെ പകർത്താം, ഇല്ലാതാക്കാം, പുനർനാമകരണം ചെയ്യാം എന്ന് ഞങ്ങൾ വിശദമായി പരിശോധിക്കും. ടൈപ്പ് ചെയ്ത ഫയലുകളിൽ വിവരങ്ങൾ എങ്ങനെ വായിക്കാമെന്നും എഴുതാമെന്നും നമുക്ക് പഠിക്കാം.

ഉപയോഗിച്ച് ഫയലുകൾ പകർത്തുന്നു.

ഇത് ചെയ്യുന്നതിന്, ഫയലുകൾ പ്രത്യേകമായി പകർത്തുന്ന ഒരു ഫംഗ്ഷൻ മാത്രം വിളിക്കേണ്ടതുണ്ട്. ഇതാണ് CopyFile() ഫംഗ്‌ഷൻ. ഇതിന് മൂന്ന് പാരാമീറ്ററുകളുണ്ട്, അവയിൽ രണ്ടെണ്ണം ആവശ്യമാണ്. പൂർണ്ണമായ വാക്യഘടന ഇതാ.
കോപ്പിഫയൽ("പ്രാരംഭ ഫയലിലേക്കുള്ള പാത", "എവിടെ പകർത്തണം എന്നതിലേക്കുള്ള പാത", പുനരാലേഖനം ചെയ്യുകയോ വേണ്ടയോ)

ഉദാഹരണം: CopyFile("D:sekretBD.txt","C: ame.txt", true);

ആദ്യ പാരാമീറ്ററിൽ നിങ്ങൾക്ക് മാത്രമല്ല വ്യക്തമാക്കാൻ കഴിയും മുഴുവൻ പാതഫയലിലേക്ക്. ഉദാഹരണത്തിന്, "sekretBD.txt" എന്ന പാത ഞങ്ങൾ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഞങ്ങളുടെ പ്രോഗ്രാം അതിൻ്റെ ഡയറക്ടറിയിൽ ഈ ഫയലിനായി നോക്കും. പേരും അനുമതിയും ഫയലിനുള്ളത് പോലെ തന്നെ വ്യക്തമാക്കിയിരിക്കണം, അല്ലാത്തപക്ഷം പ്രോഗ്രാം ഫയൽ കണ്ടെത്തുകയില്ല.
രണ്ടാമത്തെ പാരാമീറ്ററിൽ നിങ്ങൾക്ക് വ്യക്തമാക്കാനും കഴിയും ആപേക്ഷിക പാതഅവിടെ നിങ്ങൾക്ക് ആവശ്യമുള്ളതുപോലെ ഫയലിൻ്റെ പേരും വിപുലീകരണവും വ്യക്തമാക്കാൻ കഴിയും. ആ. ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പേരുമാറ്റാനും കഴിയും.
ഫയൽ തിരുത്തിയെഴുതുന്നതിന് മൂന്നാമത്തെ പാരാമീറ്റർ ഉത്തരവാദിയാണ്. ശരി എന്ന് ഞങ്ങൾ വ്യക്തമാക്കിയാൽ, ഫയൽ തിരുത്തിയെഴുതപ്പെടില്ല, തെറ്റാണെങ്കിൽ, പ്രോഗ്രാം ഫയലിനെ പുനരാലേഖനം ചെയ്യും.

ഉപയോഗിച്ച് ഫയലുകളുടെ പേരുമാറ്റുന്നു

RenameFile() ഫംഗ്‌ഷൻ ഫയലുകളുടെ പേരുമാറ്റുന്നതിനുള്ള ഉത്തരവാദിത്തമാണ്. ഇതിന് 2 പാരാമീറ്ററുകൾ ഉണ്ട്. അതിൻ്റെ പൂർണ്ണമായ വാക്യഘടന ഇതാ
RenameFile("ഫയലിലേക്കുള്ള പാത","പുതിയ പേര്");
സത്യം പറഞ്ഞാൽ, ഈ ഫംഗ്‌ഷൻ്റെ വാക്യഘടനയിൽ ഞാൻ പ്രത്യേകിച്ച് സന്തുഷ്ടനല്ല. അതിൽ, രണ്ട് പാരാമീറ്ററുകളിലും നിങ്ങൾ മുഴുവൻ പാതയും വ്യക്തമാക്കേണ്ടതുണ്ട്. ആ. ഞങ്ങൾ, ഉദാഹരണത്തിന്, ഇതുപോലെ എഴുതുകയാണെങ്കിൽ

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

അപ്പോൾ അത് പ്രോഗ്രാം ഡയറക്ടറിയിലേക്ക് ഫയൽ പകർത്തും. ആ. ഇത് ഒരു പകർപ്പായി പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് ഇത് മാറുന്നു. ഇത് അൽപ്പം വിചിത്രമാണ്.

ഉപയോഗിച്ച് ഫയലുകൾ ഇല്ലാതാക്കുന്നു

ശരി, ഇവിടെ എല്ലാം വളരെ ലളിതമാണ്. ഒരു ഫയൽ ഇല്ലാതാക്കാൻ ഉപയോഗിക്കാവുന്ന പ്രവർത്തനത്തെ ഇതുപോലെ വിളിക്കുന്നു:

DeleteFile("C:myprofile.txt");

ഒരേയൊരു കാര്യം അത് എല്ലായ്പ്പോഴും ഫയൽ 100% ഇല്ലാതാക്കില്ല എന്നതാണ്. ഫയൽ പരിരക്ഷിക്കുമ്പോൾ, അവൾക്ക് അത് ഇല്ലാതാക്കാൻ കഴിയില്ല.

ടൈപ്പ് ചെയ്ത ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു

ടൈപ്പ് ചെയ്ത ഫയൽ എന്താണ്? ഇത് ഒരു പ്രത്യേക ഘടനയുള്ള ഫയലാണ്. സാധാരണയായി ഈ ഘടന രേഖകൾ ആണ് അടിസ്ഥാന തരങ്ങൾ. പൊതുവേ, തരം അറിയപ്പെടുന്നത് പ്രധാനമാണ് നിശ്ചിത വലിപ്പം, അതിനാൽ സ്ട്രിംഗ് തരം ഉപയോഗിക്കാൻ കഴിയില്ല, നിങ്ങൾ ഇത് ചെയ്യേണ്ടതുണ്ട്: String[N].
ആദ്യം നമ്മൾ ഫയലിൽ നിന്നുള്ള ഡാറ്റ സംഭരിക്കുന്ന ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട്. ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:

Var f: ഫയൽ<Тип>
ഉദാഹരണത്തിന്, f: സ്ട്രിംഗിൻ്റെ ഫയൽ;

അപ്പോൾ നമ്മൾ ഫയലുമായി ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. ഇതിനായി ഒരു AssignFile കമാൻഡ് ഉണ്ട്. വിളിക്കാൻ, നിങ്ങൾ രണ്ട് പാരാമീറ്ററുകൾ വ്യക്തമാക്കേണ്ടതുണ്ട്, ഇതാണ് ഞങ്ങൾ മുകളിൽ പ്രഖ്യാപിച്ച വേരിയബിളും ഫയലിലേക്കുള്ള പാതയും. ഉദാഹരണത്തിന്

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

ഇപ്പോൾ ഫയൽ തുറക്കേണ്ടതുണ്ട്. ഇത് രണ്ട് തരത്തിൽ തുറക്കാം: വീണ്ടും പൊടിച്ചോ അല്ലാതെയോ. റീറൈറ്റ് രീതി ആദ്യം സൃഷ്ടിച്ചതിന് ശേഷം ഒരു ഫയൽ തുറക്കുന്നു. ആ. ഞങ്ങൾ വ്യക്തമാക്കിയ പാതയിൽ ഫയൽ സ്ഥിതിചെയ്യുന്നില്ലെങ്കിൽ, അത് അത് സൃഷ്ടിക്കും. അത്തരമൊരു ഫയൽ ഇതിനകം ഉണ്ടായിരുന്നെങ്കിൽ, അത് ഇല്ലാതാക്കുകയും വീണ്ടും സൃഷ്ടിക്കുകയും ചെയ്യും ഫയൽ വൃത്തിയാക്കുക. റീസെറ്റ് രീതി ഫയൽ തുറക്കുകയും ഫയലിൻ്റെ തുടക്കത്തിൽ തന്നെ പോയിൻ്റർ സ്ഥാപിക്കുകയും ചെയ്യുന്നു. എന്നാൽ ഈ രീതി അപകടകരമാണ്, കാരണം കണക്ഷനിൽ വ്യക്തമാക്കിയ ഫയൽ നിലവിലില്ലെങ്കിൽ, പ്രോഗ്രാം ഒരു പിശക് ഉപയോഗിച്ച് ക്രാഷ് ചെയ്യും. അതുകൊണ്ട് ശരിയായ അപേക്ഷപിശകുകൾ പ്രവർത്തനരഹിതമാക്കാൻ റീസെറ്റ് ഫംഗ്‌ഷന് കംപൈലറോട് പറയേണ്ടതുണ്ട്. ഇത് നിർദ്ദേശം ($I-) വ്യക്തമാക്കുന്നു, അതായത്. മുഴുവൻ വാക്യഘടന പ്രവർത്തനങ്ങൾ പുനഃസജ്ജമാക്കുകഇതുപോലെ ആയിരിക്കും:

($I-)
റീസെറ്റ് (എഫ്);
($I+)

ഇതിനുശേഷം, ഫയൽ തുറന്നോ ഇല്ലയോ എന്ന് നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്. IOResult ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും. ഇത് പൂജ്യമല്ലെങ്കിൽ, എല്ലാം വിജയകരമാണ്.
മുഴുവൻ വാക്യഘടന:

($I-)
റീസെറ്റ് (എഫ്);
($I+)
IOresult എങ്കിൽ<>0 അപ്പോൾ<ваш код>

FileExists ഫംഗ്‌ഷൻ നിങ്ങളെ പരിശോധിക്കാൻ സഹായിക്കും. ഇത് ഫയലിലേക്കുള്ള പാത സൂചിപ്പിക്കേണ്ടതുണ്ട്.
ഒരു ഫയൽ വായിക്കാൻ, രണ്ട് പാരാമീറ്ററുകൾ വ്യക്തമാക്കുന്ന Read() ഫംഗ്ഷൻ ഉപയോഗിക്കുക: ഫയൽ വേരിയബിളും റെക്കോർഡ് തരവും, ഞങ്ങളുടെ കാര്യത്തിൽ അത് സ്ട്രിംഗ് ആണ്. വാക്യഘടന:

ഒരു ഫയലിലേക്ക് എഴുതാൻ, റൈറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിക്കുക, അത് ഒരേ രണ്ട് പാരാമീറ്ററുകൾ വ്യക്തമാക്കുന്നു: ഫയൽ വേരിയബിളും റെക്കോർഡ് തരവും, ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് സ്ട്രിംഗ് ആണ്. വാക്യഘടന:

eof(f) ചെയ്യാത്തപ്പോൾ
വായിക്കുക(f,സ്ട്രിംഗ്);

ഒരു തിരയൽ ഫംഗ്ഷനുമുണ്ട്, അതിലൂടെ നമുക്ക് താൽപ്പര്യമുള്ള റെക്കോർഡിലേക്ക് പോകാം. ഉദാഹരണത്തിന്, ഞങ്ങൾക്ക് റെക്കോർഡ് 20 ആക്സസ് ചെയ്യേണ്ടതുണ്ട്, ഞങ്ങൾ ഇത് ചെയ്യുന്നു:

ഒരു ട്രങ്കേറ്റ് ഫംഗ്ഷനും ഉണ്ട്, അതിലൂടെ നമുക്ക് ഒരു ഫയലിലെ എല്ലാ എൻട്രികളും ഇല്ലാതാക്കാൻ കഴിയും, പോയിൻ്റർ സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്നു. മനസ്സിലാകാത്തവർക്ക് സീക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് സ്ഥാനം വ്യക്തമാക്കാം.

ഫയലിനൊപ്പം എല്ലാ പ്രവർത്തനങ്ങളും പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങൾ അത് CloseFile (f) ഫംഗ്ഷൻ ഉപയോഗിച്ച് അടയ്ക്കേണ്ടതുണ്ട്;
അത്രയേയുള്ളൂ. ഇത് പാഠം അവസാനിപ്പിക്കുന്നു. സൈറ്റിൽ കാണാം!

പാഠം 15. ഫയലുകളുമായി പ്രവർത്തിക്കുന്നു

ഈ പാഠത്തിൽ നമ്മൾ വളരെ നോക്കും പ്രധാനപ്പെട്ട വിഷയംപ്രോഗ്രാമിംഗിൽ - ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു.
മിക്കവാറും എല്ലാ പ്രോഗ്രാമുകളിലും നിങ്ങൾ ഫയലുകൾ പകർത്തുകയും തുറക്കുകയും മാറ്റുകയും സംരക്ഷിക്കുകയും ചിലപ്പോൾ ഇല്ലാതാക്കുകയും ചെയ്യേണ്ടതുണ്ട്.

നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ഫയലുകൾ ഉണ്ട് വിവിധ ഫോർമാറ്റുകൾഅവർക്ക് ബാധകമാക്കുകയും ചെയ്യുക വിവിധ പരിപാടികൾപ്രോസസ്സിംഗിനായി. ഉദാഹരണത്തിന്, BMP ചിത്ര ഫയലുകൾ, ടെക്സ്റ്റ് TXT ഫയലുകൾഇത്യാദി. ഫയലുകൾക്ക് വ്യത്യസ്ത പേരുകളും ഒരു പ്രത്യേക വിപുലീകരണവുമുണ്ട് MS-DOS പരിസ്ഥിതിപരമാവധി മൂന്ന് പ്രതീകങ്ങൾ. ഫയലിന് ഒരു RAR വിപുലീകരണമുണ്ടെങ്കിൽ, ഉപയോക്താവും ഓപ്പറേറ്റിംഗ് സിസ്റ്റവും സിസ്റ്റം അറിയുന്നുഇതൊരു ആർക്കൈവർ ആണെന്നും, windowsw വ്യക്തമാക്കിയിട്ടുള്ള ടൂളുകൾ ഉപയോഗിക്കുന്നു പ്രത്യേക വിഭാഗംരജിസ്ട്രി

ഫയലുകൾ പകർത്തുന്നു

ഫയലുകൾ പകർത്താൻ കോപ്പിഫയൽ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. അതിൻ്റെ ഫോർമാറ്റ് ഇതുപോലെയാണ്:

കോപ്പിഫയൽ (Source_file, Write_file, Overwrite_flag);

എവിടെ: Source_file – പകർത്തുന്ന ഫയലിൻ്റെ മുഴുവൻ പാതയും പേരും;

Write_file - ഉറവിട ഫയൽ പകർത്തിയ ഫയലിൻ്റെ മുഴുവൻ പാതയും പേരും;

Overwrite_flag - ഫയൽ നിലവിലുണ്ടെങ്കിൽ അത് തിരുത്തിയെഴുതപ്പെടുമോ ഇല്ലയോ എന്നത് (ശരി - അത് ആയിരിക്കില്ല, തെറ്റ് - അത് തിരുത്തിയെഴുതപ്പെടും).

പകർപ്പ് പ്രവർത്തനം വിജയിച്ചാലും ഇല്ലെങ്കിലും ഒരു ഫ്ലാഗ് നൽകുന്ന ഒരു ഫംഗ്‌ഷനാണ് കോപ്പിഫയൽ.

ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന വരി:

CopyFile ("c:\command.com","c:\1.com",true) ഇല്ലെങ്കിൽ, ShowMessage("പകർപ്പ് പിശക്");

രണ്ടാമത്തേത് നിലവിലില്ലെങ്കിൽ മാത്രമേ command.com ഫയൽ 1.com ഫയലിലേക്ക് പകർത്തൂ, അല്ലാത്തപക്ഷം അത് ഒരു കോപ്പി പിശക് സന്ദേശം പ്രദർശിപ്പിക്കും.

ഫയലുകൾ നീക്കുന്നു

ഫയലുകൾ നീക്കാൻ MoveFile ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. അവൾക്ക് ഉണ്ട് അടുത്ത ഫോർമാറ്റ്:

MoveFile (Source_file, Write_file);

റീറൈറ്റ് ഫ്ലാഗിൻ്റെ അഭാവം ഒഴികെ അതിൻ്റെ പാരാമീറ്ററുകൾ മുകളിലുള്ള കമാൻഡിന് സമാനമാണ്.

MoveFile ("c:\1.com","c:\2.com") ഇല്ലെങ്കിൽ, ShowMessage("Move error");

ഫയലുകളുടെ പേരുമാറ്റുന്നു

ഫയൽ ഫംഗ്‌ഷൻ പുനർനാമകരണം ചെയ്യുക

RenameFile ("c:\2.com","c:\3.com") ഇല്ലെങ്കിൽ, ShowMessage("Rename error");

മുകളിലുള്ള എല്ലാ കമാൻഡുകൾക്കും പ്രാരംഭവും ഉണ്ട് അന്തിമ ഫയൽ PChar ഇനത്തിലുള്ളതാണ്. ഈ സ്ട്രിംഗ് തരം null-terminated. ഈ സ്ട്രിംഗ് ഡാറ്റ ഫോർമാറ്റിനെക്കുറിച്ച് നിങ്ങൾ മുമ്പ് കേട്ടിരിക്കാം. അത്തരമൊരു വേരിയബിളിൽ നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗ് ഇടാം നീണ്ട നീളം. അവസാനം ഒരു നൾ ബൈറ്റിൻ്റെ സാന്നിധ്യത്താൽ അതിൻ്റെ വലുപ്പം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു. സൈദ്ധാന്തികമായി, അത്തരമൊരു വേരിയബിളിന് അനന്തമായ വലുപ്പമുണ്ടാകാം. പ്രായോഗികമായി, പ്രോഗ്രാമിനായി അനുവദിച്ച മെമ്മറിയുടെ വലുപ്പം (2GB) പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.

സാധാരണ പരിവർത്തനം ചെയ്യുക സ്ട്രിംഗ് വേരിയബിൾ, സ്ട്രിംഗ് ടൈപ്പ് ചെയ്യുക PChar ൽ ഫംഗ്ഷൻ നിർമ്മിക്കുന്നത്:

PChar(String_variable).

അതേ സമയം, ടീമുകൾക്ക് ഫയൽ പ്രവർത്തനങ്ങൾചരടുകളുടെ സംയോജനം സാധ്യമാണ്. ഉദാഹരണത്തിന്:

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

Var InDir,OutDir:String; // സ്ട്രിംഗ് വേരിയബിളുകളുടെ പ്രഖ്യാപനം

ആരംഭിക്കുന്നു

InDir:="c:\1\"; // ഡയറക്ടറി ഉറവിട ഫയലുകൾ

OutDir:="c:\2\"; // എഴുതേണ്ട ഫയലുകളുടെ ഡയറക്ടറി

കോപ്പിഫയൽ(PChar(InDir+"1.txt"),PChar(OutDir+"1.txt"),false);

കോപ്പിഫയൽ(PChar(InDir+"2.txt"),PChar(OutDir+"2.txt"),false);

അവസാനിക്കുന്നു;

ഇവിടെ നമുക്ക് രണ്ട് സ്ട്രിംഗ് വേരിയബിളുകൾ സംയോജിപ്പിക്കുന്ന പ്രവർത്തനമുണ്ട്.

c:\1\1.txt, c:\1\2.txt എന്നീ ഫയലുകൾ c:\2 ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നതാണ് ഈ നടപടിക്രമത്തിൻ്റെ ഫലം. ഫയലുകൾ അതേ പേരിലാണ് പകർത്തിയിരിക്കുന്നത്.

ഫയലുകൾ ഇല്ലാതാക്കുന്നു

ഫയൽ ഫംഗ്‌ഷൻ ഇല്ലാതാക്കുക

DeleteFile("c:\3.com") ഇല്ലെങ്കിൽ, ShowMessage("Delete error");

ടെക്സ്റ്റ് ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു. ഒരു ടെക്സ്റ്റ് ഫയലിൽ നിന്ന് വായിക്കുന്നു

മുമ്പത്തെ പാഠങ്ങളിൽ, ഞങ്ങൾ, മെമ്മോ ഘടകത്തിൽ, ഒരു ടെക്സ്റ്റ് ഫയൽ ലോഡുചെയ്യുന്നതിനും എഴുതുന്നതിനുമുള്ള പ്രക്രിയ ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്തു:

Memo1.Lines.SaveToFile(FileName); // സംരക്ഷണം

ഇതെല്ലാം ലൈനുകൾ സംഭരിക്കുന്ന ലൈൻസ് പ്രോപ്പർട്ടിക്ക് നന്ദി.

ഒരു ടെക്സ്റ്റ് ഫയൽ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള ഇനിപ്പറയുന്ന ഉദാഹരണം പാസ്കലിൽ ഉള്ളതിന് സമാനമാണ്.
അറിവുള്ള ആളുകൾചില വ്യത്യാസങ്ങൾ ഉള്ളതിനാൽ വ്യത്യാസം അനുഭവപ്പെട്ടേക്കാം.

നടപടിക്രമംTForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

വാർഫ്:ടെക്സ്റ്റ് ഫയൽ; // ഫയൽ വേരിയബിൾ ഡിക്ലറേഷൻ

സെൻ്റ്: സ്ട്രിംഗ്; // സ്ട്രിംഗ് വേരിയബിൾ

ആരംഭിക്കുന്നു

AssignFile(f,"c:\1.txt"); // ഫയലിൻ്റെ പേര് ഒരു ഫയൽ വേരിയബിളിലേക്ക് ബന്ധിപ്പിക്കുന്നു

($I-) // I/O പിശക് പരിശോധന പ്രവർത്തനരഹിതമാക്കുക

റീസെറ്റ് (എഫ്); // വായിക്കാൻ ഫയൽ തുറക്കുക

($I+) // I/O പിശക് പരിശോധിക്കൽ പ്രവർത്തനക്ഷമമാക്കുക

എങ്കിൽ ഫലം<>0 പിന്നെ// ഉണ്ടെങ്കിൽ തുറക്കൽ പിശക്, അത്

ആരംഭിക്കുന്നു

ShowMessage("ഫയൽ C:\1.TXT തുറക്കുന്നതിൽ പിശക്");

പുറത്ത്; // ഒരു ഫയൽ തുറക്കുന്നതിൽ പിശക് ഉണ്ടെങ്കിൽ നടപടിക്രമത്തിൽ നിന്ന് പുറത്തുകടക്കുക

അവസാനിക്കുന്നു;

അതേസമയം അല്ല EOF(f) ചെയ്യുക// ഇനിയും ഇല്ല ഫയലിൻ്റെ അവസാനംഒരു ലൂപ്പ് ചെയ്യുക:

ആരംഭിക്കുന്നു

ShowMessage(st); // ഉപയോക്താവിന് ഒരു സ്ട്രിംഗ് ഔട്ട്പുട്ട് ചെയ്യുക

അവസാനിക്കുന്നു;

ക്ലോസ്ഫയൽ(എഫ്); // ഫയൽ അടയ്ക്കുക

അവസാനിക്കുന്നു;

ഈ ഉദാഹരണത്തിലെ ചില വരികളിൽ ഞാൻ അഭിപ്രായം പറയട്ടെ.

AssignFile കമാൻഡ് ഒരു ഫയൽ പാത്ത് സ്ട്രിംഗ് ഒരു ഫയൽ വേരിയബിളുമായി ബന്ധിപ്പിക്കുന്നു. ഫയൽ വേരിയബിളുമായുള്ള എല്ലാ തുടർന്നുള്ള പ്രവർത്തനങ്ങളും സ്വയമേവ നടപ്പിലാക്കുന്നു വ്യക്തമാക്കിയ ഫയൽ. ആശയക്കുഴപ്പം ഒഴിവാക്കാൻ, ഫയലിലേക്കുള്ള മുഴുവൻ പാതയും വ്യക്തമാക്കുക.

($I-), ($I+) എന്നിവ യഥാക്രമം ഈ ഘട്ടത്തിൽ I/O പിശക് പരിശോധിക്കുന്നത് പ്രവർത്തനരഹിതമാക്കാനും പ്രവർത്തനക്ഷമമാക്കാനുമുള്ള കംപൈലറിനുള്ള നിർദ്ദേശങ്ങളാണ്. ഈ സാഹചര്യത്തിൽ, c:\1.txt ഫയൽ തുറക്കാനുള്ള ശ്രമം പരാജയപ്പെട്ടാൽ (ഫയൽ കാണുന്നില്ല അല്ലെങ്കിൽ മറ്റൊരു പ്രോഗ്രാം എഴുതാൻ തുറന്നിരിക്കുന്നു), ഞങ്ങളുടെ പ്രോഗ്രാം ഒരു അടിയന്തര പിശക് സൃഷ്ടിക്കില്ല, ഈ നടപടിക്രമം തുടർന്നും നടപ്പിലാക്കും. എല്ലാം കൈകാര്യം ചെയ്യാൻ ഈ പ്രോപ്പർട്ടി ഉപയോഗപ്രദമാണ് സാധ്യമായ കേസുകൾപ്രോഗ്രാമിൻ്റെ പ്രവർത്തനത്തിൽ.

കഴിഞ്ഞ I/O ഓപ്പറേഷൻ്റെ പിശക് കോഡ് സംഭരിക്കുന്ന ഒരു വേരിയബിളാണ് IOResult. ഇത് പൂജ്യമാണെങ്കിൽ, അവസാന പ്രവർത്തനം വിജയകരമായി പൂർത്തിയാക്കി.

EOF(ഫയൽ) - ഫയലിൻ്റെ അവസാന ചിഹ്നം നൽകുന്ന ഒരു ഫംഗ്‌ഷൻ. ആ. തുറന്ന ഫയലിൻ്റെ അവസാനം എത്തിയോ ഇല്ലയോ എന്ന് ഇത് കാണിക്കുന്നു.

ReadLn (ഫയൽ, വേരിയബിൾ) - ഒരു ഫയലിൽ നിന്ന് ഒരു വേരിയബിൾ വായിക്കുന്നതിനുള്ള നടപടിക്രമം. റീഡ് കമാൻഡിന് വിപരീതമായി, 13, 10 കോഡുകൾക്ക് കീഴിൽ ഒരു പുതിയ ലൈൻ പ്രതീകത്തിൽ അവസാനിക്കുന്ന ഒരു വരി ഇത് വായിക്കുന്നു (കീ നൽകുക).

CloseFile(ഫയൽ) - മുമ്പ് തുറന്ന ഒരു ഫയൽ ക്ലോസ് ചെയ്യുന്നതിനുള്ള നടപടിക്രമം.

ടെക്സ്റ്റ് ഫയലുകളിൽ പ്രവർത്തിക്കുന്നു. ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് എഴുതുന്നു

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

Var f:TextFile; // ടെക്സ്റ്റ് ഫയലിലേക്കുള്ള പോയിൻ്റർ

AssignFile(f,"c:\1.txt"); // പേര് ഒരു വേരിയബിളിലേക്ക് ബന്ധിപ്പിക്കുന്നു

അനുബന്ധം(എഫ്); // ചേർക്കുന്നതിനായി ഫയൽ തുറക്കുക

IORsult എങ്കിൽ<>0 പിന്നെ //തുറക്കുന്നതിൽ ഒരു പിശക് ഉണ്ടെങ്കിൽ (ഉദാഹരണത്തിന്, ഒരു ഫയലും ഇല്ല)

വീണ്ടും എഴുതുക(എഫ്); // സൃഷ്ടിക്കാൻ പുതിയ ഫയൽ

IORsult എങ്കിൽ<>0 തുടർന്ന് // ഫയൽ സൃഷ്‌ടിക്കൽ പിശക്

ShowMessage("ഫയൽ സൃഷ്ടിക്കുന്നതിൽ പിശക്:\1.TXT");

WriteLn(f,"ഹലോ"); // ഒരു ഫയലിലേക്ക് പുതിയ ലൈൻ പ്രതീകങ്ങളുള്ള ഒരു സ്ട്രിംഗ് എഴുതുക

ക്ലോസ്ഫയൽ(എഫ്); // ഫയൽ അടയ്ക്കുക

അനുബന്ധ നടപടിക്രമം എഴുതുന്നതിനായി ഒരു ഫയൽ തുറക്കുകയും ഫയലിൻ്റെ അവസാനത്തിൽ റൈറ്റ് പോയിൻ്റർ സജ്ജമാക്കുകയും ചെയ്യുന്നു, അതായത്. ഫയലിലേക്ക് ചേർത്ത എല്ലാ വരികളും ഫയലിൻ്റെ അവസാനം വരെ എഴുതപ്പെടും.

ഞങ്ങളുടെ കാര്യത്തിൽ, ഫയലിൻ്റെ തുടക്കത്തിൽ തന്നെ, 1.txt ഡിസ്കിൽ ഉണ്ടാകണമെന്നില്ല, അതിനാൽ ചേർക്കുന്നതിനായി ഫയൽ തുറക്കുന്നതിനുള്ള കമാൻഡ് ഒരു പിശകിന് കാരണമാകും. ഈ സാഹചര്യത്തിൽ, ഞങ്ങളുടെ സ്വന്തം പിശക് പരിശോധന പ്രവർത്തനക്ഷമമാവുകയും ഫയൽ സൃഷ്ടിക്കുന്നതിനുള്ള കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

ഒരു ഫയലിൽ നിന്ന് ടെക്സ്റ്റ് ഇതര ഡാറ്റ എഴുതുകയും വായിക്കുകയും ചെയ്യുന്നു

ഒരു പ്രോഗ്രാം, പുറത്തുകടക്കുമ്പോൾ, സ്ക്രീനിലെ വിൻഡോയുടെ വലുപ്പവും സ്ഥാനവും ഒരു ഫയലിലേക്ക് സംരക്ഷിക്കുകയും തുടർന്നുള്ള സമാരംഭത്തിൽ, പുറത്തുകടക്കുമ്പോൾ ഉണ്ടായിരുന്ന അവസ്ഥ പുനഃസ്ഥാപിക്കുകയും ചെയ്യുന്ന ഒരു ഉദാഹരണം നോക്കാം. പ്രോഗ്രാമിൻ്റെ ഫോം1 വിൻഡോയ്‌ക്കായി ഓൺഷോ, ഓൺക്ലോസ് എന്നീ രണ്ട് നടപടിക്രമങ്ങൾ പ്രോഗ്രാമിൽ അടങ്ങിയിരിക്കുന്നു.

നടപടിക്രമം TForm1.FormShow(അയക്കുന്നയാൾ: TObject);

വര് f: ഫയൽ യുടെപൂർണ്ണസംഖ്യ; // ഫയൽ വേരിയബിൾ, പൂർണ്ണസംഖ്യ എന്ന് ടൈപ്പ് ചെയ്യുക

ഞാൻ:പൂർണ്ണസംഖ്യ; // പൂർണ്ണസംഖ്യ വേരിയബിൾ

ആരംഭിക്കുന്നു

AssignFile(f,"pos.ini");

($I-)

റീസെറ്റ് (എഫ്);

($I+)

എങ്കിൽ IORഫലം<>0 പിന്നെപുറത്ത്;

ഫോം1. ടോപ്പ്: = ഞാൻ; // മുകളിലെ വിൻഡോ സ്ഥാനം

വായിക്കുക(f,i);

ഫോം1.ഇടത്:=ഞാൻ; // ഇടത് വിൻഡോ സ്ഥാനം

വായിക്കുക(f,i);

ഫോം1. വീതി: = ഞാൻ; // വിൻഡോ വീതി

വായിക്കുക(f,i);

ഫോം1.ഉയരം:=ഞാൻ; // വിൻഡോ ഉയരം

ക്ലോസ്ഫയൽ(എഫ്);

അവസാനിക്കുന്നു;

നടപടിക്രമം TForm1.FormClose(അയക്കുന്നയാൾ: TObject; varപ്രവർത്തനം: TCLoseAction);

വര് f: ഫയൽ യുടെപൂർണ്ണസംഖ്യ;

പേരിട്ടിരിക്കുന്ന മെമ്മറി ഏരിയ ഓണാണ് ബാഹ്യ മാധ്യമങ്ങൾ(ഡിസ്ക്) എന്ന് വിളിക്കുന്നു ഫയൽ. ഏതെങ്കിലും ഫയലുണ്ട് പേര്. വിവരങ്ങൾ, ഒരു ഫയലിൽ സംഭരിച്ചിരിക്കുന്നത് ഒരേ തരത്തിലുള്ള ഘടകങ്ങളുടെ ഒരു കൂട്ടമാണ്. വലിപ്പംഒരു ഫയൽ സാധാരണയായി അത് സംഭരിച്ചിരിക്കുന്ന ഉപകരണത്തിൻ്റെ ശേഷിയിൽ മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, ഇത് വലിയ അളവിലുള്ള വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നത് സാധ്യമാക്കുന്നു.

പ്രഖ്യാപന രീതിഫയൽ അതിൻ്റെ തരത്തെ ആശ്രയിച്ചിരിക്കുന്നു. മൂന്ന് തരം ഫയലുകളുണ്ട്:

വാചകം;

ടൈപ്പ് ചെയ്തു;

ടൈപ്പ് ചെയ്യാത്തത്.

ടെക്സ്റ്റ് ഫയൽ, ഏതെങ്കിലും പ്രതീകങ്ങളുടെ ഒരു ക്രമം ഉൾക്കൊള്ളുന്നു. പ്രതീകങ്ങൾ വരികൾ രൂപപ്പെടുത്തുന്നു, അവ ഓരോന്നും അവസാനിക്കുന്നത് വരിയുടെ അവസാനത്തെ പ്രതീകത്തിലാണ്. ഫയലിൻ്റെ അവസാനം "ഫയലിൻ്റെ അവസാനം" എന്ന ചിഹ്നത്താൽ സൂചിപ്പിച്ചിരിക്കുന്നു. ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് വിവരങ്ങൾ എഴുതുമ്പോൾ, എല്ലാ ഡാറ്റയും ഒരു പ്രതീക തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും ഈ ഫോമിൽ സംഭരിക്കുകയും ചെയ്യുന്നു. ഏതെങ്കിലും ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ടെക്സ്റ്റ് ഫയൽ കാണാൻ കഴിയും ടെക്സ്റ്റ് എഡിറ്റർ.

ടെക്സ്റ്റ് ഫയലിൻ്റെ വിവരണം:

var variable_name: TextFile;

ടൈപ്പ് ചെയ്ത ഫയൽഒരേ തരത്തിലുള്ള ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്നു, അവയുടെ എണ്ണം മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടില്ലാത്തതും ഏതെങ്കിലും ആകാം. "ഫയലിൻ്റെ അവസാനം" എന്ന ചിഹ്നത്തിലും ഇത് അവസാനിക്കുന്നു. ടൈപ്പ് ചെയ്ത ഫയലിലെ ഡാറ്റ സംഭരിച്ചിരിക്കുന്നു ബൈനറി കോഡുകൾകാണുന്നില്ല ടെക്സ്റ്റ് എഡിറ്റർമാർ. അത്തരം ഫയലുകളുടെ പ്രഖ്യാപനം ഇതുപോലെ കാണപ്പെടുന്നു:

variable_name: തരം ഫയൽ;

IN ടൈപ്പ് ചെയ്യാത്ത ഫയലുകൾവിവരങ്ങൾ ഫോമിൽ വായിക്കുകയും എഴുതുകയും ചെയ്യുന്നു ബ്ലോക്കുകൾഒരു നിശ്ചിത വലുപ്പത്തിൽ, അവർക്ക് ഏത് തരത്തിലും ഘടനയിലും ഡാറ്റ സംഭരിക്കാനാകും. ടൈപ്പ് ചെയ്യാത്ത ഫയലിൻ്റെ വിവരണം:

var variable_name: ഫയൽ;

വേണ്ടി ഫയൽ ആക്സസ്ഒരു പ്രത്യേക ഉപയോഗിക്കുക ഫയൽ വേരിയബിൾ.

ഉദാഹരണത്തിന്:

c:file of integer;

വേണ്ടി ആശയവിനിമയങ്ങൾഡിസ്കിലുള്ള ഒരു ഫയൽ ഉപയോഗിച്ച് ഫയൽ വേരിയബിൾ, നടപടിക്രമം ഉപയോഗിക്കുക:

AssignFile (വേരിയബിൾ, ഫയലിൻ്റെ പേര്);

ഇവിടെ വേരിയബിൾ എന്നത് ഏതെങ്കിലും ഒരു വേരിയബിളിൻ്റെ പേരാണ് ഫയൽ തരം, file_name എന്നത് ഒരു പ്രതീക സ്ട്രിംഗാണ് പൂർണ്ണമായ പേര്ഫയൽ (ഫയലിലേക്കുള്ള പാത വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് അതിൽ ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു നിലവിലെ ഡയറക്ടറി).

ഉദാഹരണത്തിന്:

എസ്:='text.txt';

അസൈൻ (f,'d:\tp\tmp\abc.dat');

വേണ്ടി കണ്ടെത്തലുകൾ നിലവിലുള്ള ഫയൽ നടപടിക്രമം ഉപയോഗിക്കുക:

പുനഃസജ്ജമാക്കുക (file_variable);

ഒരു ഫയൽ തുറന്ന ശേഷം, അതിൻ്റെ ആദ്യ ഘടകം ലഭ്യമാണ്.

ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുന്നതിനോ നിലവിലുള്ളതിൽ നിന്ന് വിവരങ്ങൾ ഇല്ലാതാക്കുന്നതിനോ, ഇനിപ്പറയുന്ന നടപടിക്രമം ഉപയോഗിക്കുക:

റീറൈറ്റ് (file_variable);

വധശിക്ഷയ്ക്ക് ശേഷം വിവിധ പ്രവർത്തനങ്ങൾഫയൽ ആയിരിക്കണം അടച്ചു. ഇത് ചെയ്യുന്നതിന്, നടപടിക്രമം ഉപയോഗിക്കുക

ക്ലോസ് ഫയൽ (ഫയൽ_വേരിയബിൾ);

ഡാറ്റ റെക്കോർഡിംഗ്ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് നടപടിക്രമങ്ങൾ നടപ്പിലാക്കുന്നു

എഴുതുക (വേരിയബിൾ, എക്സ്പ്രഷൻ_ലിസ്റ്റ്);

Writeln(വേരിയബിൾ, എക്സ്പ്രഷൻ_ലിസ്റ്റ്);

എക്സ്പ്രഷൻ_ലിസ്റ്റ് ഒരു പ്രതീകം, പൂർണ്ണസംഖ്യ, യഥാർത്ഥം, സ്ട്രിംഗ് അല്ലെങ്കിൽ ബൂളിയൻ തരങ്ങൾ, ഇത് ഫയൽ വേരിയബിളുമായി ബന്ധപ്പെട്ട ഫയലിലേക്ക് എഴുതപ്പെടും.

Writeln നടപടിക്രമം ഓരോ വരിയുടെയും അവസാനം ഒരു ലൈൻ ടെർമിനേറ്റർ ചേർക്കുന്നു.

ഉദാഹരണം. ഡിസ്കിൽ സൃഷ്ടിക്കുന്ന ഒരു സബ്റൂട്ടീൻ ഡിഫയൽ abc.txtഅതിൽ ഗുണനപ്പട്ടിക എഴുതുകയും ചെയ്യുന്നു.

var f:TextFile; i,j:ബൈറ്റ്;

അസൈൻ ഫയൽ(f,"d:\abc.txt");

ഞാൻ വേണ്ടി:=2 മുതൽ 9 വരെ

j:= 2 മുതൽ 9 വരെ ചെയ്യുക

എഴുതുക(f,i,"*",j,"=",i*j," ");

ഡാറ്റ വായിക്കുന്നുഫയലിൽ നിന്ന് നടപടിക്രമം ഫയലിൻ്റെ തുടക്കം മുതൽ തുടർച്ചയായി നടപ്പിലാക്കുന്നു

Readln(വേരിയബിൾ, വേരിയബിൾ_ലിസ്റ്റ്);

ഇവിടെ variables_list, ഫയൽ വേരിയബിളുമായി ബന്ധപ്പെട്ട ഫയലിൽ നിന്ന് വായിക്കുന്ന ഡാറ്റ എഴുതപ്പെടുന്ന വേരിയബിളുകളെ പട്ടികപ്പെടുത്തുന്നു.

Readln നടപടിക്രമം, ഫയലിൽ നിന്ന് അടുത്ത ഘടകം വായിച്ചതിനുശേഷം, അടുത്ത വരിയിലേക്ക് നീങ്ങുന്നു.

ഇനിപ്പറയുന്ന സബ്റൂട്ടീനെ വിളിക്കുന്നത് എഡിറ്റിംഗ് വിൻഡോയിലെ ഫോമിൽ ഫയലിൽ നിന്നുള്ള വാചകം ദൃശ്യമാകും D:\abc.txt:

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

a:string; ഞാൻ:പൂർണ്ണസംഖ്യ;

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

ഞാൻ വേണ്ടി:=1 മുതൽ 8 വരെ

Memo1.Lines.Add(a);

ടൈപ്പ് ചെയ്ത ഫയലുകൾക്കും ബാധകമാണ് വായന നടപടിക്രമങ്ങൾഒപ്പം രേഖകള്

വായിക്കുക (വേരിയബിൾ, വേരിയബിളുകളുടെ പട്ടിക);

എഴുതുക (വേരിയബിൾ, എക്സ്പ്രഷൻ_ലിസ്റ്റ്);

റൈറ്റും റീഡും എക്സ്പ്രഷൻ തരങ്ങൾ മാത്രം പ്രഖ്യാപിത ഫയൽ തരവുമായി പൊരുത്തപ്പെടണം. ടൈപ്പ് ചെയ്ത ഫയലുകൾക്ക് Writeln, Readln നടപടിക്രമങ്ങൾ ബാധകമല്ല.

വേണ്ടി ടൈപ്പ് ചെയ്ത ഫയലിലൂടെ നീങ്ങുന്നുനടപടിക്രമം ഉപയോഗിക്കുക:

സീക്ക് (വേരിയബിൾ, നമ്പർ);

ഈ നടപടിക്രമം ഉപയോഗിച്ച് ഒരു ഘടകത്തിലേക്ക് നാവിഗേറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു നിർദ്ദിഷ്ട നമ്പർ, അതായത്, അത് നടപ്പിലാക്കുന്നു ഫയൽ ഘടകങ്ങളിലേക്ക് നേരിട്ടുള്ള ആക്സസ്. നേരിട്ടുള്ള ആക്‌സസ് ഉപയോഗിച്ച്, ഫയൽ ഘടകങ്ങളെ 0 മുതൽ n-1 വരെ അക്കമിട്ടിരിക്കുന്നു, ഇവിടെ n എന്നത് ഫയലിലെ ഘടകങ്ങളുടെ എണ്ണമാണ്.

ടൈപ്പ് ചെയ്‌ത ഫയലിൻ്റെ ഘടകങ്ങൾ നേരിട്ട് ആക്‌സസ് ചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫംഗ്‌ഷനുകളും ഉപയോഗിക്കാം:

ഫയലുകളുടെ വലുപ്പം (വേരിയബിൾ) - യഥാർത്ഥ ഘടകങ്ങളുടെ എണ്ണം നൽകുന്നു ഫയൽ തുറക്കുകഫയൽ_വേരിയബിളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു (ഇതിനായി ശൂന്യമായ ഫയൽഫംഗ്ഷൻ 0 തിരികെ നൽകും);

filepos (വേരിയബിൾ) - ഫയൽ വേരിയബിളുമായി ബന്ധപ്പെട്ട ഓപ്പൺ ഫയലിലെ നിലവിലെ സ്ഥാനത്തിൻ്റെ മൂല്യം നൽകുന്നു (ഫയൽ ഇപ്പോൾ തുറന്നിട്ടുണ്ടെങ്കിൽ, ഫംഗ്ഷൻ പൂജ്യം നൽകും; ഫയലിൽ നിന്നുള്ള അവസാന ഘടകം വായിച്ചതിനുശേഷം, ഫംഗ്ഷൻ മൂല്യം പൊരുത്തപ്പെടുന്നു filesize value, ഫയലിൻ്റെ അവസാനം എത്തി എന്ന് സൂചിപ്പിക്കുന്നു).

സീക്ക് നടപടിക്രമവും ഫയലുകളുടെ വലുപ്പവും ഫയൽപോസ് ഫംഗ്ഷനുകളും ടെക്സ്റ്റ് ഫയലുകളിൽ പ്രവർത്തിക്കില്ല. ടൈപ്പ് ചെയ്‌തതും ടെക്‌സ്‌റ്റ് ഫയലുകളും ഉപയോഗിച്ച് ഇനിപ്പറയുന്ന ദിനചര്യകൾ പ്രവർത്തിക്കുന്നു:

പേരുമാറ്റുക (വേരിയബിൾ, ഫയലിൻ്റെ പേര്)

ഫയൽ നെയിം ലൈനിൽ വ്യക്തമാക്കിയ പേരിന് അനുസൃതമായി ഫയൽ വേരിയബിളുമായി ബന്ധപ്പെട്ട അടച്ച ഫയലിനെ പുനർനാമകരണം ചെയ്യുന്നു;

മായ്ക്കുക (വേരിയബിൾ) - ഇല്ലാതാക്കുന്നു അടച്ച ഫയൽ, ഒരു ഫയൽ വേരിയബിളുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു;

ഫയൽ_വേരിയബിളുമായി ബന്ധപ്പെട്ട ഫയലിൻ്റെ അവസാനത്തിൽ എത്തിയാൽ Eof(വേരിയബിൾ) true ആയി വിലയിരുത്തുന്നു, അല്ലാത്തപക്ഷം തെറ്റ്;

ഉദാഹരണം. താഴെയുള്ള സബ്റൂട്ടീൻ ഇതുപോലെ പ്രവർത്തിക്കുന്നു. ഒരു യഥാർത്ഥ ഫയൽ തുറക്കുന്നു d:\abc.datഒരു നിശ്ചിത തുക അതിൽ എഴുതിയിരിക്കുന്നു യഥാർത്ഥ സംഖ്യകൾ, ഫോർമുല ഉപയോഗിച്ച് കണക്കാക്കുന്നു. സൃഷ്ടിച്ച ഫയൽ കാണാൻ കഴിയില്ല, കാരണം അതിലെ വിവരങ്ങൾ ബൈനറി കോഡുകളിൽ അവതരിപ്പിച്ചിരിക്കുന്നു.

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

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

n:=StrToInt(Edit1.Text);

i:=1 മുതൽ n വരെ

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

ഫയലിലേക്ക് എഴുതുന്നത് ഉറപ്പാക്കാൻ d:\abc.datവിജയകരമായി സംഭവിച്ചു, എഡിറ്റിംഗ് വിൻഡോയിൽ അതിൻ്റെ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കാം:

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

f1: യഥാർത്ഥ ഫയൽ;

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

eof (f1) ചെയ്യാത്തപ്പോൾ

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

ചുമതല. ഡിസ്കിൽ ഇപൂർണ്ണസംഖ്യകളുടെ ഒരു ഫയൽ ഉണ്ട് abc.int, അതിൻ്റെ പരമാവധി, കുറഞ്ഞ ഘടകങ്ങൾ സ്വാപ്പ് ചെയ്യുക.

ഇനിപ്പറയുന്ന പ്രോഗ്രാം ഇതുപോലെ പ്രവർത്തിക്കുന്നു. ഫയലിൻ്റെ ഘടകങ്ങൾ ഒരു അറേയിൽ വായിക്കുന്നു. അറേ ഘടകങ്ങൾ Memo1 ഫീൽഡിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. തുടർന്ന് അറേയുടെ ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ ഘടകങ്ങളും അവയുടെ സൂചികകളും തിരയുന്നു. പരമാവധി, കുറഞ്ഞ ഘടകങ്ങൾ ഫയലിലേക്ക് അനുബന്ധ സ്ഥാനങ്ങളിൽ വീണ്ടും എഴുതുന്നു.

അവസാനമായി, പരിവർത്തനം ചെയ്ത ഫയലിൻ്റെ ഘടകങ്ങൾ Memo2 ഫീൽഡിൽ പ്രദർശിപ്പിക്കും.

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

എഫ്: പൂർണ്ണസംഖ്യയുടെ ഫയൽ;

ഒരു: പൂർണ്ണസംഖ്യകളുടെ നിര;

i,nmax,nmin:byte; പരമാവധി,മിനി:പൂർണ്ണസംഖ്യ;

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

i:=0 to filesize(f)-1 do

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

പരമാവധി:=എ; nmax:=0;

മിനിറ്റ്:=എ; nmin:=0;

i:=1 to filesize(f)-1 do

a[i]>പരമാവധി എങ്കിൽ

എങ്കിൽ[i]

i:=0 to filesize(f)-1 do

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

ഫയൽഒരു ഡിസ്കിലോ മറ്റേതെങ്കിലും ബാഹ്യ സംഭരണ ​​ഉപകരണത്തിലോ സ്ഥിതി ചെയ്യുന്ന അതേ തരത്തിലുള്ള ഡാറ്റ ഘടകങ്ങളുടെ ഒരു ശ്രേണിയാണ് പേരുള്ള ഡാറ്റാ ഘടന.

ഒരു ഫയലിൻ്റെ നിലവിലെ സ്ഥാനം എന്ന ആശയം ഉണ്ട്. അടുത്ത തവണ ഫയൽ ആക്‌സസ് ചെയ്യുമ്പോൾ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്ന ഘടകത്തിൻ്റെ എണ്ണം ഇത് കാണിക്കുന്നു. ഓരോ ഘടകങ്ങളും വായിക്കുകയും എഴുതുകയും ചെയ്യുന്നത് നിലവിലെ സ്ഥാനത്തെ ഒന്നായി മുന്നോട്ട് നീക്കുന്നു. മിക്ക ഫയലുകൾക്കും, അതിൻ്റെ ഘടകങ്ങൾ നേരിട്ട് ആക്സസ് ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് നിലവിലെ റീഡ്-റൈറ്റ് സ്ഥാനം മാറ്റാനാകും.

ഘടകങ്ങളുടെ തരം അനുസരിച്ച്, മൂന്ന് തരം ഫയലുകൾ ഉണ്ട്:

- ഒരു പ്രത്യേക തരത്തിലുള്ള ഘടകങ്ങളുടെ ഒരു ഫയൽ (ടൈപ്പ് ചെയ്ത ഫയലുകൾ);

- തരം വ്യക്തമാക്കിയിട്ടില്ലാത്ത ഘടകങ്ങളുടെ ഒരു ഫയൽ (ടൈപ്പ് ചെയ്യാത്ത ഫയൽ);

- ടെക്സ്റ്റ് ഫയൽ, അതായത്. ഘടകങ്ങൾ ടെക്സ്റ്റ് സ്ട്രിംഗുകളാണ്.

പ്രോഗ്രാമിലെ ഒരു ഫയലുമായി പ്രവർത്തിക്കാൻ, വേരിയബിൾ വിവരണ വിഭാഗത്തിൽ ഒരു ഫയൽ വേരിയബിൾ (ലോജിക്കൽ ഫയൽ) പ്രഖ്യാപിച്ചു:

ഫയലിന്റെ പേര്:ഫയൽഫയൽ_ഇനം_തരം;

പ്രതീക ഡാറ്റയായ ഘടകങ്ങളുള്ള ഒരു ഫയലിനെ പ്രതീകം അല്ലെങ്കിൽ വാചകം എന്ന് വിളിക്കുന്നു:

ഫയലിന്റെ പേര്:ടെക്സ്റ്റ് ഫയൽ;

ഫയൽ ഘടകങ്ങളുടെ തരം വ്യക്തമാക്കുന്ന ഒരു ഫയൽ വേരിയബിൾ പ്രഖ്യാപിച്ച ശേഷം, നിങ്ങൾ ഒരു നിർദ്ദിഷ്ട ഫയൽ വ്യക്തമാക്കണം, അതായത്. ഒരു ഫിസിക്കൽ ഫയലുമായി ഒരു ഫയൽ വേരിയബിളിനെ ബന്ധപ്പെടുത്തുക. ഇത് ചെയ്യുന്നതിന്, നടപടിക്രമം ഉപയോഗിക്കുക:

അസൈൻ ഫയൽ(varf, ഫയലിൻ്റെ പേര്:സ്ട്രിംഗ്);

ഫയലുകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങളും നടപടിക്രമങ്ങളും:

1. എഴുതുന്നതിനായി ഒരു ഫയൽ തുറക്കുന്നു

- ഓവർറൈറ്റിംഗ് (നിലവിലുള്ള ഒന്നിന് മുകളിൽ ഒരു പുതിയ ഫയൽ എഴുതുക അല്ലെങ്കിൽ ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുക) - നടപടിക്രമം ഉപയോഗിക്കുന്നു

മാറ്റിയെഴുതുക(file_variable)

- ഫയലിൻ്റെ അവസാനം ചേർക്കുന്നു - നടപടിക്രമം ഉപയോഗിക്കുന്നു

കൂട്ടിച്ചേർക്കുക(file_variable)

1. ഫയലിലേക്ക് എഴുതുക

എഴുതുക

എഴുതിയത്(file_variable, variable_list)

നിർദ്ദേശങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം, എല്ലാ മൂല്യങ്ങളും പ്രിൻ്റ് ചെയ്‌ത ശേഷം, ഫയലിലേക്ക് ഒരു പുതിയ ലൈൻ പ്രതീകം എഴുതുന്ന നിർദ്ദേശം.

2. ഫയൽ അടയ്ക്കുന്നു.ഷട്ട് ഡൗൺ ചെയ്യുന്നതിന് മുമ്പ്, എല്ലാ തുറന്ന ഫയലുകളും നടപടിക്രമം ഉപയോഗിച്ച് അടച്ചിരിക്കണം

ക്ലോസ് ഫയൽ(file_variable)

3. വായിക്കാൻ ഒരു ഫയൽ തുറക്കുന്നു.ഉപയോഗിച്ച നടപടിക്രമം പുനഃസജ്ജമാക്കുക(file_variable)

4. ഒരു ഫയലിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നു

വായിച്ചു(file_variable, variable_list)

വായിക്കുക(file_variable, variable_list)

ഈ നടപടിക്രമങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം, readln സ്റ്റേറ്റ്‌മെൻ്റ് വിളിക്കുമ്പോൾ, ഫയലിൽ നിന്നുള്ള റീഡ് പോയിൻ്റർ ഫയലിൻ്റെ അടുത്ത വരിയുടെ തുടക്കത്തിലേക്ക് സ്വയമേവ നീക്കപ്പെടും എന്നതാണ്.

5. ഫയലിൻ്റെ അവസാനം നിർണ്ണയിക്കുന്നു.ഉപയോഗിച്ച പ്രവർത്തനം EOF(file_variable). വായിച്ച ഡാറ്റ എലമെൻ്റ് ഫയലിലെ അവസാനത്തേതല്ലെങ്കിൽ ഫംഗ്ഷൻ മൂല്യം തെറ്റാണ്, അതായത്. കൂടുതൽ വായന സാധ്യമാണ്. വായിച്ച ഫയൽ ഘടകം അവസാനത്തേതാണെങ്കിൽ, EOF ശരിയാണ്.

eof (f) അല്ലെങ്കിലും ആരംഭിക്കുക ... അവസാനിക്കുക;

6. പേരുമാറ്റുക(var F; പുതിയ പേര്: സ്ട്രിംഗ്)- ഏതെങ്കിലും തരത്തിലുള്ള തുറക്കാത്ത ഫയലിൻ്റെ പേരു മാറ്റുന്നു. പുതിയ പേര് NewName ൽ വ്യക്തമാക്കിയിട്ടുണ്ട്.

7. അന്വേഷിക്കുക( var F; NumRec: ദൈർഘ്യമേറിയത്)– NumRec എന്ന നമ്പറുള്ള ഘടകത്തിലേക്ക് റീഡ്-റൈറ്റ് സ്ഥാനം സജ്ജമാക്കുന്നു; എഫ് - ടൈപ്പ് ചെയ്തതോ ടൈപ്പ് ചെയ്യാത്തതോ ആയ ഫയൽ.

8. IORഫലം:ഇൻ്റെ ജി er - അവസാനത്തെ I/O ഓപ്പറേഷൻ്റെ ഫലം (ഒരു പിശക് ഉണ്ടായാലും ഇല്ലെങ്കിലും) കാണിക്കുന്ന ഒരു കോഡ് നൽകുന്നു.

9. ഫയൽപോസ്(var F): നീളം– ഫയലിൻ്റെ നിലവിലെ ഫയൽ സ്ഥാനം തിരികെ നൽകുന്നു (അത് ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്ന ഘടകത്തിൻ്റെ എണ്ണം, പൂജ്യത്തിൽ നിന്ന് കണക്കാക്കുന്നു). ടെക്സ്റ്റ് ഫയലുകൾക്കൊപ്പം ഉപയോഗിക്കുന്നില്ല.

10. ഫയൽ വലുപ്പം(var F): നീളം- എഫ് ഫയലിലെ ഘടകങ്ങളുടെ എണ്ണം നൽകുന്നു. ടെക്സ്റ്റ് ഫയലുകൾക്കൊപ്പം ഉപയോഗിക്കില്ല.

ഫയലുകളിൽ പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ഉപയോഗിക്കാം ദൃശ്യ ഘടകങ്ങൾ:

– (SITELINK-S102)ഓപ്പൺ ഡയലോഗ്(/SITELINK);

– (SITELINK-S103)SaveDialog(/SITELINK) മുതലായവ, ഡയലോഗ് ടാബിൽ സ്ഥിതി ചെയ്യുന്നു.

ഒരു പുതിയ ഡെൽഫി പ്രോജക്റ്റ് സൃഷ്ടിക്കുക. ഒന്നാമതായി, ഞങ്ങൾ പ്രോഗ്രാം ഇൻ്റർഫേസ് വികസിപ്പിക്കും. പ്രധാന രൂപത്തിൻ്റെ ചില സവിശേഷതകൾ മാറ്റാം. ഒന്നാമതായി, അടിക്കുറിപ്പ് പ്രോപ്പർട്ടിക്ക് (ഫോം ശീർഷകം) ഉചിതമായ മൂല്യം നൽകുക - ഉദാഹരണത്തിന്, ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുക. ഞങ്ങളുടെ പ്രോഗ്രാം വിൻഡോ എല്ലായ്‌പ്പോഴും മറ്റെല്ലാ വിൻഡോകൾക്കും മുകളിലായിരിക്കണം എന്നതിനാൽ, ഞങ്ങൾ FormStyle പ്രോപ്പർട്ടി fsStayOnTop ആയി സജ്ജീകരിക്കണം. ഫോമിൻ്റെ കൂടുതൽ സവിശേഷതകളൊന്നും ഞങ്ങൾ മാറ്റില്ല.

ഫോമിൻ്റെ മുകളിൽ ഇടത് കോണിൽ രണ്ട് വിഭാഗ ലേബൽ ഘടകങ്ങൾ സ്ഥാപിക്കുക, ഒന്നിനു മുകളിൽ മറ്റൊന്ന്. സ്റ്റാൻഡേർഡ്. മുകളിലെ ലേബലിന്, അടിക്കുറിപ്പ് പ്രോപ്പർട്ടി What: എന്നും രണ്ടാമത്തേതിന് എവിടെ: എന്നും സജ്ജീകരിക്കുക. ലേബലുകൾക്ക് അടുത്തായി, വിഭാഗത്തിൻ്റെ ഒരു എഡിറ്റ് ഘടകം (ഇൻപുട്ട് ഫീൽഡ്) സ്ഥാപിക്കുക സ്റ്റാൻഡേർഡ്. മുകളിലെ ഫീൽഡിൻ്റെ നെയിം പ്രോപ്പർട്ടി ഫ്രം ആയും താഴെയുള്ള ഫീൽഡിൻ്റെ നെയിം പ്രോപ്പർട്ടി എവിടേയ്ക്കും സജ്ജമാക്കുക. from.Text, where.Text പ്രോപ്പർട്ടികൾ എന്നിവ ഡിഫോൾട്ട് പാത്തുകളായി സജ്ജമാക്കുക, ഉദാഹരണത്തിന്: c:\1.txt, d:\2.txt.

ഫയൽ പാതകൾ പകർത്തുന്നതിനോ സ്വമേധയാ നൽകുന്നതിനോ ഉപയോക്താവിനെ ബുദ്ധിമുട്ടിക്കാതിരിക്കാൻ, ഫയലുകൾ തുറക്കുന്നതിനും സംരക്ഷിക്കുന്നതിനും ഞങ്ങൾ സാധാരണ ഡയലോഗ് ബോക്സുകൾ ഉപയോഗിക്കും. ഫയൽ ഓപ്പൺ ഡയലോഗ് ബോക്സ് OpenDialog വിഭാഗ ഘടകവുമായി യോജിക്കുന്നു ഡയലോഗുകൾ, കൂടാതെ സേവ് ഡയലോഗ് ബോക്സ് - അതേ വിഭാഗത്തിലെ SaveDialog ഘടകം. ഈ ഘടകങ്ങൾ ഫോമിൽ സ്ഥാപിക്കാം. സൗകര്യാർത്ഥം, നമുക്ക് OpenDialog1.Name പ്രോപ്പർട്ടിയുടെ മൂല്യം Open1 ആയും SaveDialog1.Name പ്രോപ്പർട്ടിയുടെ മൂല്യം Save1 ആയും മാറ്റാം.

ഫീൽഡുകളിൽ നിന്നും എവിടെ നിന്നും വലതുവശത്ത് ഞങ്ങൾ അവലോകന ഡയലോഗ് ബോക്സിലേക്ക് വിളിക്കുന്നതിനുള്ള ബട്ടണുകൾ സ്ഥാപിക്കും (ബട്ടൺ വിഭാഗത്തിൻ്റെ ഘടകങ്ങൾ സ്റ്റാൻഡേർഡ്). ഈ ബട്ടണുകളുടെ അടിക്കുറിപ്പ് പ്രോപ്പർട്ടി അവലോകനം ചെയ്യാനോ ഡോട്ടുകൾ ചേർക്കാനോ സജ്ജമാക്കുക. വേണമെങ്കിൽ, നിങ്ങൾക്ക് ബട്ടണുകളുടെ വലുപ്പം മാറ്റാം.

എവിടെ ഫീൽഡിന് താഴെയുള്ള ഫോമിൽ കാറ്റഗറി ലേബൽ ഘടകം സ്ഥാപിക്കുക സ്റ്റാൻഡേർഡ്കൂടാതെ അതിൻ്റെ അടിക്കുറിപ്പ് പ്രോപ്പർട്ടി ഫയൽ വലുപ്പത്തിലേക്ക് സജ്ജമാക്കുക:. ഈ ലേബലിൻ്റെ വലതുവശത്ത്, മറ്റൊരു ലേബൽ ഘടകം സ്ഥാപിക്കുക, അതിൻ്റെ അടിക്കുറിപ്പ് പ്രോപ്പർട്ടി മായ്‌ക്കുക - ഈ ലേബൽ പ്രോസസ്സ് ചെയ്യുന്ന ഫയലിൻ്റെ വലുപ്പം പ്രദർശിപ്പിക്കും.

ചുവടെ ഞങ്ങൾ രണ്ട് ബട്ടണുകൾ (ബട്ടൺ ഘടകങ്ങൾ) സ്ഥാപിക്കും, അവയുടെ ക്യാപ്ഷൻ പ്രോപ്പർട്ടികൾ പകർത്തുക, മുറിക്കുക എന്ന മൂല്യങ്ങൾ നൽകുക. ഈ ബട്ടണുകൾക്ക് താഴെ ഞങ്ങൾ ഫയലുകൾ തിരഞ്ഞെടുക്കുന്നതിനും ഇല്ലാതാക്കുന്നതിനും ഉപയോഗിക്കുന്ന ഘടകങ്ങൾ സ്ഥാപിക്കും: ഫയലിലേക്കുള്ള പാതയിൽ പ്രവേശിക്കുന്നതിനുള്ള എഡിറ്റ് ഘടകം, ബ്രൗസ് ഡയലോഗ് ബോക്സിലേക്ക് വിളിക്കുന്നതിനുള്ള ഒരു ബട്ടൺ, ഫയൽ ഇല്ലാതാക്കുന്നതിനുള്ള ഒരു ബട്ടൺ.

നമുക്ക് Edit1.Name പ്രോപ്പർട്ടി ഡെൽ ആയും ടെക്സ്റ്റ് പ്രോപ്പർട്ടി ഡിഫോൾട്ട് പാഥിലും സജ്ജീകരിക്കാം. ബട്ടൺ അവലോകനംഅത് വലതുവശത്ത് വയ്ക്കുക, ബട്ടൺ ഒരു ഫയൽ ഇല്ലാതാക്കുക- ഡെൽ ഫീൽഡിന് കീഴിൽ.

തത്ഫലമായുണ്ടാകുന്ന രൂപം ചിത്രം അനുസരിച്ചായിരിക്കണം. 2.1

അരി. 2.1 ഫോം ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

പ്രോഗ്രാം കോഡ് വികസനം

ഒരു ഫയൽ പകർത്തുന്നതിനുള്ള ഒരു നടപടിക്രമം നമുക്ക് വികസിപ്പിക്കാം. WinAPI ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കാൻ കഴിയും, എന്നാൽ ഈ സാഹചര്യത്തിൽ നടപടിക്രമം, ബുദ്ധിമുട്ട് കുറവാണെങ്കിലും, പ്രോഗ്രാമുകൾക്ക് അഭികാമ്യമല്ലാത്ത സിസ്റ്റവുമായി "ബന്ധിതമാകും", അതിനാൽ ഡെൽഫി ലൈബ്രറികൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

ആദ്യം, ഫോം ക്ലാസിലെ ഒരു സ്വകാര്യ അംഗമായി നമ്മുടെ നടപടിക്രമം (ഇതിനെ ഡോയിറ്റ് എന്ന് വിളിക്കാം) പ്രഖ്യാപിക്കാം:

നടപ്പിലാക്കൽ വിഭാഗത്തിൽ ഞങ്ങൾ നടപടിക്രമം നടപ്പിലാക്കും:

നടപടിക്രമം TForm1.doit();

f1, f2: ബൈറ്റ് ഫയൽ;//ആദ്യത്തേയും രണ്ടാമത്തെയും ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുക

സോർ: ബൈറ്റ്;//ബൈറ്റ്-ബൈ-ബൈറ്റ് പകർത്തുന്നതിന്

വലിപ്പം: LongInt;//ഫയൽ വലുപ്പം സംഭരിക്കുന്നു

($I-)//പിശകുകൾ ട്രാക്ക് ചെയ്യുന്ന നിർദ്ദേശം പ്രവർത്തനരഹിതമാക്കുക

ശ്രമിക്കുക//ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ ബ്ലോക്കിൻ്റെ തുടക്കം

//ഫയൽ വേരിയബിൾ f1 ആദ്യ ഫയലുമായി ബന്ധപ്പെടുത്തുക

AssignFile(f1, from.Text);

//ഫയൽ വേരിയബിൾ f2 രണ്ടാമത്തെ ഫയലുമായി ബന്ധപ്പെടുത്തുക

AssignFile(f2, എവിടെ. ടെക്സ്റ്റ്);

പുനഃസജ്ജമാക്കുക(f1); //വായനയ്ക്കായി ആദ്യത്തെ ഫയൽ തുറക്കുക

വലിപ്പം:= ട്രങ്ക്(ഫയലിൻ്റെ വലിപ്പം(f1)); //ഫയൽ വലുപ്പം നിർണ്ണയിക്കുക

//ഉപയോക്താക്കൾക്കുള്ള ഫയൽ വലുപ്പം പ്രദർശിപ്പിക്കുക

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

ആരംഭിക്കുന്നു//ആദ്യ ഫയലിൻ്റെ അവസാനം വരെ

//ആദ്യ ഫയലിൽ നിന്ന് ഒരു ബൈറ്റ് വായിക്കുക

BlockRead(fl, cop, 1);

//രണ്ടാമത്തെ ഫയലിലേക്ക് ഒരു ബൈറ്റ് എഴുതുക

ബ്ലോക്ക് റൈറ്റ്(f2, കോപ്പ്, 1);

ക്ലോസ് ഫയൽ(f1); //ആദ്യ ഫയൽ അടയ്ക്കുക

ക്ലോസ് ഫയൽ(f2); //രണ്ടാമത്തെ ഫയൽ അടയ്ക്കുക

അവസാനിക്കുന്നു;//ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ ബ്ലോക്കിൻ്റെ അവസാനം

IORsult എങ്കിൽ<> 0 //ഒരു I/O പിശക് സംഭവിച്ചാൽ

തുടർന്ന് MessageDlg("ഫയൽ പകർത്തുന്നതിൽ പിശക്!", mtError, ,0)//പിശക് സന്ദേശം

(പിശകുകളൊന്നും ഇല്ലെങ്കിൽ, പകർത്തൽ വിജയകരമായി പൂർത്തിയാക്കിയതായി സൂചിപ്പിക്കുന്ന ഒരു വിൻഡോ ഞങ്ങൾ പ്രദർശിപ്പിക്കും)

ShowMessage("വിജയകരമായി പകർത്തി!");

⇘ ഒബ്ജക്റ്റ് പാസ്കൽ ഭാഷയുടെ വിവിധ നിർമ്മിതികൾ (അഭിപ്രായങ്ങൾ, ബ്രാഞ്ചിംഗ് ഓപ്പറേറ്റർമാർ, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ മുതലായവ) അനുബന്ധം ഡിയിൽ ചർച്ചചെയ്യുന്നു.

ഫയലുകൾ പകർത്തി കൈമാറുമ്പോൾ ഈ നടപടിക്രമം ഉപയോഗിക്കും. ഉപയോക്താവ് തിരഞ്ഞെടുത്ത ഫയലുകൾ ഞങ്ങൾ ആദ്യം തുറക്കുന്നു, തുടർന്ന് അവ തുറക്കുമ്പോൾ എന്തെങ്കിലും പിശകുകൾ ഉണ്ടോയെന്ന് പരിശോധിക്കുക. പിശകുകളൊന്നും ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഉറവിട ഫയലിൻ്റെ വലുപ്പം ഉപയോക്താവിന് പ്രദർശിപ്പിക്കുകയും ആദ്യ ഫയലിൽ നിന്ന് ബൈറ്റുകൾ വായിക്കുകയും രണ്ടാമത്തേതിലേക്ക് എഴുതുകയും ചെയ്യുന്നു. പകർത്തൽ പൂർത്തിയാകുകയും പിശകുകളൊന്നും സംഭവിക്കാതിരിക്കുകയും ചെയ്താൽ, പകർത്തൽ വിജയകരമായി പൂർത്തിയാക്കിയതായി സൂചിപ്പിക്കുന്ന ഒരു സന്ദേശം പ്രദർശിപ്പിക്കും.

ബട്ടൺ ക്ലിക്ക് ചെയ്യുമ്പോൾ doit നടപടിക്രമം വിളിക്കുന്നു പകർത്തുക:

നടപടിക്രമം TForm1.Button1Click(അയക്കുന്നയാൾ: TObject);

ഒരു ബട്ടണിൻ്റെ ക്ലിക്കിൽ മുറിക്കുകപകർത്തിയ ഫയൽ ഇല്ലാതാക്കിയതിന് ശേഷം സാധാരണ പകർത്തൽ സംഭവിക്കണം:

ചെയ്യു;//പകർപ്പ്

ഫയൽ ഇല്ലാതാക്കുക(Text-ൽ നിന്ന്); //ഉറവിട ഫയൽ ഇല്ലാതാക്കുക

ഇനി സ്റ്റാൻഡേർഡ് ഡയലോഗ് ബോക്സുകൾ ഉപയോഗിച്ച് ഒരു ഫയൽ തിരഞ്ഞെടുക്കുന്നതിനും സംരക്ഷിക്കുന്നതിനുമുള്ള നടപടിക്രമങ്ങൾ ഉണ്ടാക്കാം. ആദ്യത്തെ (ഉറവിടം) ഫയൽ തിരഞ്ഞെടുക്കുന്നതിന്, ഇനിപ്പറയുന്ന OnClick ഇവൻ്റ് ഹാൻഡ്‌ലർ സൃഷ്‌ടിക്കുക (Button2 ബട്ടൺ ഫ്രം ഫീൽഡുമായി യോജിക്കുന്നു):

തുടർന്ന് from.Text:= Open1.FileName

ബട്ടൺ അമർത്തുമ്പോൾ അവലോകനംഫയൽ തിരഞ്ഞെടുക്കൽ ഡയലോഗ് ബോക്സ് തുറക്കുന്നു (Open1.Execute). ഉപയോക്താവ് ഈ വിൻഡോയിലെ ബട്ടണിൽ ക്ലിക്ക് ചെയ്താൽ റദ്ദാക്കുക(Open1.Execute = False), തുടർന്ന് ഞങ്ങൾ ഇതിനെക്കുറിച്ച് അവനെ അറിയിക്കുകയും പ്രവർത്തനങ്ങളൊന്നും നടത്താതിരിക്കുകയും ചെയ്യും. ഉപയോക്താവ് ഒരു ഫയൽ തിരഞ്ഞെടുത്തിട്ടുണ്ടെങ്കിൽ, അതിനുള്ള പാത്ത് അനുബന്ധ ഇൻപുട്ട് ഫീൽഡിലേക്ക് പകർത്തുക.

ആദ്യ ഫയൽ പകർത്തുമ്പോൾ ഡെസ്റ്റിനേഷൻ പാത്ത് തിരഞ്ഞെടുക്കുന്നതിന് സമാനമായ ഒരു ഇവൻ്റ് ഹാൻഡ്‌ലർ സൃഷ്‌ടിക്കാം (Button3 ബട്ടൺ എവിടെ ഫീൽഡുമായി യോജിക്കുന്നു):

പിന്നെ എവിടെ.Text:= Save1.FileName

മറ്റുള്ളവ ShowMessage("ഫയൽ സംരക്ഷിക്കാൻ നിങ്ങൾ ഒരു സ്ഥലം തിരഞ്ഞെടുത്തിട്ടില്ല!");

മുമ്പത്തെ കേസിലെ അതേ പരിശോധനയാണ് ഇവിടെയും നടത്തുന്നത്. തിരഞ്ഞെടുത്ത പാത്ത് പിന്നീട് അനുബന്ധ ഇൻപുട്ട് ഫീൽഡിലേക്ക് പ്രവേശിക്കുന്നു, അങ്ങനെ ആവശ്യമെങ്കിൽ അത് ക്രമീകരിക്കാൻ കഴിയും.

ഇപ്പോൾ ബട്ടണിനായി സമാനമായ ഒരു OnClick ഇവൻ്റ് ഹാൻഡ്‌ലർ സൃഷ്ടിക്കാം അവലോകനം, ഇല്ലാതാക്കേണ്ട ഫയലിൻ്റെ സ്ഥാനം തിരഞ്ഞെടുക്കാൻ ഉപയോഗിക്കുന്നു:

തുടർന്ന് Del.Text:= Open1.FileName

മറ്റുള്ളവ ShowMessage("ഫയൽ തുറന്നിട്ടില്ല!");

ബട്ടൺ തന്നെ ഇല്ലാതാക്കുകക്ലിക്ക് ചെയ്യുമ്പോൾ ഇനിപ്പറയുന്ന കോഡ് നടപ്പിലാക്കുന്നു:

നടപടിക്രമം TForm1.Button6Click(അയക്കുന്നയാൾ: ടോബ്ജക്റ്റ്);

DeleteFile(Del.Text);//ഫയൽ ഇല്ലാതാക്കുക

FileExist ഇല്ലെങ്കിൽ (Del.Text)//ഫയലിൻ്റെ നിലനിൽപ്പ് പരിശോധിക്കുക

തുടർന്ന് ShowMessage("ഫയൽ ഇല്ലാതാക്കി!");//ഒരു സന്ദേശം പ്രദർശിപ്പിക്കുക

ഞങ്ങൾ ആദ്യം ഫയൽ ഇല്ലാതാക്കുക, തുടർന്ന് ഡിലീറ്റ് ഓപ്പറേഷൻ നടത്തിയതിന് ശേഷം അത് ഡിസ്കിൽ ഉണ്ടോ എന്ന് പരിശോധിക്കുക. അത് നിലവിലില്ലെങ്കിൽ, ഫയൽ വിജയകരമായി ഇല്ലാതാക്കിയെന്ന് സൂചിപ്പിക്കുന്ന ഒരു സന്ദേശം ഞങ്ങൾ പ്രദർശിപ്പിക്കുന്നു. ഇപ്പോൾ നിങ്ങൾക്ക് പ്രോഗ്രാം കംപൈൽ ചെയ്ത് പ്രവർത്തിപ്പിക്കാം. വിൻഡോ രൂപം ഫയലുകളുമായി പ്രവർത്തിക്കുന്നുചിത്രത്തിൽ പ്രവർത്തനത്തിൽ കാണിച്ചിരിക്കുന്നു. 2.2

അരി. 2.2 ഫയൽ വർക്കിംഗ് പ്രോഗ്രാം പ്രവർത്തനത്തിലാണ്

മൊഡ്യൂൾ മുഴുവൻ സോഴ്സ് കോഡ്

ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്ന പ്രോഗ്രാം മൊഡ്യൂളിൻ്റെ പൂർണ്ണമായ കോഡ് ലിസ്റ്റിംഗ് 2.1 ൽ അവതരിപ്പിച്ചിരിക്കുന്നു.

ലിസ്റ്റിംഗ് 2.1. പ്രോഗ്രാം മൊഡ്യൂൾ ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

വിൻഡോസ്, സന്ദേശങ്ങൾ, SysUtils, വേരിയൻ്റുകൾ, ക്ലാസുകൾ, ഗ്രാഫിക്സ്, നിയന്ത്രണങ്ങൾ, ഫോമുകൾ, ഡയലോഗുകൾ, StdCtrls, ShellAPI, ഗേജുകൾ;

നടപടിക്രമം ബട്ടൺ1 ക്ലിക്ക് (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം Button2Click (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം Button3Click (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം Button5Click (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം Button4Click (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം Button6Click (അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം ഡോയിറ്റ്; // നടപടിക്രമങ്ങളുടെ പ്രഖ്യാപനം ഡോയിറ്റ്

f1, f2: ബൈറ്റ് ഫയൽ; //ആദ്യത്തേയും രണ്ടാമത്തെയും ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുക

ലിറ്റർ: ബൈറ്റ്; //ബൈറ്റ്-ബൈ-ബൈറ്റ് പകർത്തുന്നതിന്

വലിപ്പം: നീളം; // ഫയൽ വലുപ്പം സംഭരിക്കുന്നു

(I-) (I/O പിശകുകൾ നിരീക്ഷിക്കുന്ന നിർദ്ദേശം പ്രവർത്തനരഹിതമാക്കുക)

//ഫയൽ വേരിയബിൾ f1 ആദ്യ ഫയലുമായി ബന്ധപ്പെടുത്തുക

//ഫയൽ വേരിയബിൾ f2 രണ്ടാമത്തെ ഫയലിലേക്ക് ബൈൻഡ് ചെയ്യുക

പുനഃസജ്ജമാക്കുക(f1); //ആദ്യ ഫയൽ വായിക്കാൻ തുറക്കുക

sizez:= Trunc(FileSize(f1)); //ഫയലിൻ്റെ വലിപ്പം കണ്ടുപിടിക്കുക

//ഉപയോക്താക്കൾക്കായി ഫയൽ വലുപ്പം പ്രദർശിപ്പിക്കുക)

Label4.Caption:= IntToStr(sizez div 1024) + "Kb';

(രണ്ടാമത്തെ ഫയൽ സൃഷ്ടിക്കുക അല്ലെങ്കിൽ അത് നിലവിലുണ്ടെങ്കിൽ അത് തിരുത്തിയെഴുതുക)

Eof(f1) അല്ലാത്തപ്പോൾ //ആദ്യ ഫയലിൻ്റെ അവസാനം എത്തുന്നതുവരെ

//ആദ്യ ഫയലിൽ നിന്ന് ഒരു ബൈറ്റ് വായിക്കുക

//രണ്ടാമത്തെ ഫയലിലേക്ക് ഒരു ബൈറ്റ് എഴുതുക

CloseFile(f1);//ആദ്യ ഫയൽ അടയ്ക്കുക

CloseFile(f2); // രണ്ടാമത്തെ ഫയൽ അടയ്ക്കുക

IORsult എങ്കിൽ<>0 //ഒരു I/O പിശക് സംഭവിച്ചാൽ

തുടർന്ന് MessageDlg("ഫയൽ പകർത്തുന്നതിൽ പിശക്!", mtError, , 0) //പിശക് സന്ദേശം

(പിശകുകളൊന്നും ഇല്ലെങ്കിൽ, പകർത്തൽ വിജയകരമായി പൂർത്തിയാക്കിയതായി സൂചിപ്പിക്കുന്ന ഒരു വിൻഡോ ഞങ്ങൾ പ്രദർശിപ്പിക്കും)

ShowMessage("വിജയകരമായി പകർത്തി!");

നടപടിക്രമം TForm1.ButtonlClick(അയക്കുന്നയാൾ: TObject);

നടപടിക്രമം TForm1.Button2Click(അയക്കുന്നയാൾ: TObject);

Open1.Execute എങ്കിൽ from.Text:= Open1.FileName

മറ്റുള്ളവ ShowMessage("ഫയൽ തുറന്നിട്ടില്ല");

നടപടിക്രമം TForm1.Button3Click(അയക്കുന്നയാൾ: TObject);

Save1.Execute എങ്കിൽ എവിടെ.Text:= Save1.FileName

മറ്റുള്ളവ ShowMessage(""നിങ്ങൾ ഫയൽ സംരക്ഷിക്കാൻ ഒരു സ്ഥലം തിരഞ്ഞെടുത്തിട്ടില്ല!");

നടപടിക്രമം TForm1.Button5Click(അയക്കുന്നയാൾ: TObject);

DeleteFile(From.Text); //ഉറവിട ഫയൽ ഇല്ലാതാക്കുക

നടപടിക്രമം TForm1.Button4Click(അയക്കുന്നയാൾ: TObject);

Open1.Execute എങ്കിൽ del.Text:= Open1.FileName

മറ്റുള്ളവ ShowMessage("ഫയൽ തിരഞ്ഞെടുത്തിട്ടില്ല");

നടപടിക്രമം TForm1.Button6Click(അയക്കുന്നയാൾ: TObject);

DeleteFile(del.Text); //ഫയൽ ഇല്ലാതാക്കുക

തുടർന്ന് // ഫയലിൻ്റെ നിലനിൽപ്പ് പരിശോധിക്കുക

//വിജയകരമായ ഇല്ലാതാക്കലിനെക്കുറിച്ചുള്ള ഒരു സന്ദേശം പ്രദർശിപ്പിക്കുക

ShowMessage("ഫയൽ ഇല്ലാതാക്കി!");

⊚ എല്ലാ പ്രോജക്റ്റ് ഫയലുകളും ചർച്ച ചെയ്ത പ്രോഗ്രാമിൻ്റെ എക്സിക്യൂട്ടബിൾ ഫയലും Chapter_02 ഫോൾഡറിൽ പുസ്തകത്തോടൊപ്പം ഉൾപ്പെടുത്തിയിട്ടുള്ള CD യിലാണ് സ്ഥിതി ചെയ്യുന്നത്.