ഐനോഡ് ഘടനയുടെ ഒരു ഫീൽഡിൻ്റെ മൂല്യം മാത്രം നൽകുന്ന ഒരു കൂട്ടം യൂണറി ഓപ്പറേറ്റർമാരെ പേൾ നൽകുന്നു. ഈ പ്രവർത്തനങ്ങളെ ഡോക്യുമെൻ്റേഷനിൽ "-X പ്രവർത്തനങ്ങൾ" എന്ന് വിളിക്കുന്നു, കാരണം അവയുടെ പേരുകളിൽ ഒരു ഹൈഫൻ അടങ്ങിയിരിക്കുന്നു, തുടർന്ന് ഒരൊറ്റ പ്രതീകം. അവയെല്ലാം ഏകീകൃത നാമമുള്ള ഓപ്പറേറ്റർമാരാണ്, കൂടാതെ സങ്കീർണ്ണമായ പദപ്രയോഗങ്ങളിൽ അവരുടേതായ മുൻഗണനയുണ്ട്.

ഏകീകൃത ഫയൽ പരിശോധന പ്രവർത്തനങ്ങളുടെ പൂർണ്ണമായ ലിസ്റ്റ്

R ഫയൽ ഫലപ്രദമായ uid/gid -w ഫയലിലേക്ക് എഴുതുന്നത് ഫലപ്രദമാകാം uid/gid -x ഫയൽ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും ഫലപ്രദമായ uid/gid -o ഫയലിൻ്റെ ഉടമ ഫലപ്രദമാണ് uid/gid -R ഫയൽ സാധുതയോടെ വായിക്കാൻ കഴിയും uid/gid -W Write to file സാധുവായ uid/gid -X ഫയൽ ഒരു സാധുവായ uid/gid -O ഉപയോഗിച്ച് എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും ഫയലിൻ്റെ ഉടമ ഒരു സാധുവായ uid/gid -e ഫയൽ നിലവിലുണ്ട് -z ഫയൽ വലിപ്പം പൂജ്യമാണ് -s ഫയൽ വലുപ്പം പൂജ്യമല്ല (വലുപ്പം നൽകുന്നു) -f ഫയൽ സാധാരണമാണ് (പ്ലെയിൻ) ഫയൽ -d ഫയൽ ഒരു ഡയറക്ടറിയാണ് -l ഫയൽ ഒരു പ്രതീകാത്മക ലിങ്കാണ് -p ഫയൽ പേരുള്ള പൈപ്പാണ് (FIFO) അല്ലെങ്കിൽ പരിശോധിക്കപ്പെടുന്ന ഹാൻഡിൽ ഒരു പൈപ്പുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു -S ഫയൽ ഒരു സോക്കറ്റാണ് -b ഫയൽ ഒരു ബ്ലോക്ക് പ്രത്യേക ഫയലാണ് -c ഫയൽ ഒരു പ്രതീകാത്മക ഫയലാണ് -t ഫയൽ ഡിസ്ക്രിപ്റ്റർ ടെർമിനലുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു -u The ഫയലിൽ സെറ്റൂയിഡ് ബിറ്റ് സെറ്റ് ഉണ്ട് -g ഫയലിൽ സെറ്റ്ജിഡ് ബിറ്റ് സെറ്റ് ഉണ്ട് -k ഫയലിൽ സ്റ്റിക്കി ബിറ്റ് സെറ്റ് ഉണ്ട് -T ഫയൽ ഒരു ടെക്സ്റ്റ് ഫയലാണ് -B ഫയൽ ബൈനറി ആണ് (ടെക്‌സ്റ്റിൻ്റെ വിപരീതം) -M പ്രായത്തിലുള്ള ഫയൽ ദിവസങ്ങളിൽ പ്രോഗ്രാം എക്‌സിക്യൂഷൻ സമയത്ത് -എ ഫയലിലേക്കുള്ള അവസാന ആക്‌സസ് സമയത്തിനും സമാനമാണ് -സി ഫയൽ ഐനോഡിൻ്റെ അവസാന പരിഷ്‌ക്കരണ സമയത്തിനും സമാനമാണ്

ഒരു ഫയൽനാമം അടങ്ങുന്ന ഒരു സ്ട്രിംഗിലേക്കോ, മൂല്യനിർണ്ണയ മൂല്യമുള്ള ഒരു ഫയൽനാമത്തിലേക്കോ അല്ലെങ്കിൽ ഒരു പേൾ ഫയൽ ഡിസ്ക്രിപ്റ്ററിലേക്കോ യൂണറി പ്രവർത്തനങ്ങൾ പ്രയോഗിക്കുന്നു. ഓപ്പറേഷൻ പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് $_ എന്ന പ്രത്യേക വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന ഫയലിനെ പരിശോധിക്കുന്നു. ഫയലിന് അനുബന്ധ ആട്രിബ്യൂട്ട് ഉണ്ടെങ്കിൽ ഓരോ ഫയൽ ആട്രിബ്യൂട്ട് ചെക്ക് ഓപ്പറേഷനും 1 നൽകുന്നു, അല്ലെങ്കിൽ ശൂന്യമായ സ്ട്രിംഗ് "", കൂടാതെ നിർവചിക്കാത്തത്പരാമീറ്ററിൽ വ്യക്തമാക്കിയ ഫയൽ നിലവിലില്ലെങ്കിൽ undef.

ടെക്സ്റ്റ്, ബൈനറി ഫയലുകൾ (ഓപ്പറേഷൻസ് -T, -B) കണ്ടുപിടിക്കുന്നതിനുള്ള അൽഗോരിതം സംബന്ധിച്ച കുറച്ച് വാക്കുകൾ. ഈ പ്രവർത്തനങ്ങൾ "വിചിത്രമായ" പ്രതീകങ്ങളുടെ സാന്നിധ്യത്തിനായി ഒരു ഫയലിൻ്റെ ആദ്യ ബ്ലോക്കിലെ ഉള്ളടക്കങ്ങൾ പരിശോധിക്കുന്നു - അസാധാരണമായ രക്ഷപ്പെടൽ സീക്വൻസുകൾ അല്ലെങ്കിൽ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റുകൾ സജ്ജീകരിച്ച ബൈറ്റുകൾ. കണ്ടെത്തിയാൽ മതി ഒരു വലിയ സംഖ്യസമാന പ്രതീകങ്ങൾ (30% ൽ കൂടുതൽ), തുടർന്ന് ഫയൽ ബൈനറിയായി കണക്കാക്കുന്നു, അല്ലാത്തപക്ഷം വാചകം. ശൂന്യമായ ഫസ്റ്റ് ബ്ലോക്ക് ഉള്ള ഏതൊരു ഫയലും ബൈനറിയായി കണക്കാക്കുന്നു.

ഈ പ്രവർത്തനങ്ങൾ Perl ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളിൽ പ്രയോഗിക്കുമ്പോൾ, ഫയലിൻ്റെ ആദ്യ ബ്ലോക്കിന് പകരം I/O ബഫറിലെ ഉള്ളടക്കങ്ങൾ പരിശോധിക്കപ്പെടും. ഈ രണ്ട് പ്രവർത്തനങ്ങളും, ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾക്ക് ബാധകമാണ്, തിരികെ ബൂളിയൻ മൂല്യംഡിസ്ക്രിപ്റ്ററുമായി ബന്ധപ്പെട്ട ഫയൽ ശൂന്യമായിരിക്കുകയോ ഫയലിൻ്റെ അവസാനം വരെ സജ്ജീകരിക്കുകയോ ചെയ്താൽ ശരിയാണ്.

unary നാമത്തിലുള്ള ഫയൽ പരിശോധന പ്രവർത്തനങ്ങൾ നടത്തുമ്പോൾ, stat() ഫംഗ്‌ഷനെ യഥാർത്ഥത്തിൽ പരോക്ഷമായി വിളിക്കുന്നു, കൂടാതെ അതിൻ്റെ കണക്കുകൂട്ടലിൻ്റെ ഫലങ്ങൾ കാഷെ ചെയ്യുന്നു, ഇത് ഒരു പ്രത്യേക ഉപയോഗം അനുവദിക്കുന്നു. ഫയൽ ഡിസ്ക്രിപ്റ്റർ _ വേഗത്തിലാക്കാൻ ഒന്നിലധികം പരിശോധനകൾഫയൽ:

If(-s("filename") && -T _) ( # പൂജ്യമല്ലാത്ത വലിപ്പത്തിലുള്ള ടെക്സ്റ്റ് ഫയലുകൾക്കായി എന്തെങ്കിലും ചെയ്യുക. . . . . കകകകകകകകകകകകകകകകകകകകകകകകകകകകകകകക.

chdir

EXPRESS പാരാമീറ്ററിൻ്റെ മൂല്യം നിർവചിച്ചിരിക്കുന്ന ഡയറക്‌ടറിയിലേക്ക് നിലവിലെ പ്രവർത്തന ഡയറക്‌ടറി മാറ്റുന്നു. പരാമീറ്റർ ഒഴിവാക്കിയാൽ, ഹോം ഡയറക്ടറികറൻ്റ് ആയി മാറുന്നു. നിലവിലെ ഡയറക്‌ടറിയുടെ റീപ്ലേസ്‌മെൻ്റ് പ്രവർത്തനം വിജയകരമാണെങ്കിൽ True എന്ന മൂല്യം നൽകുന്നു, അല്ലാത്തപക്ഷം തെറ്റ്.

ച്ദിർ [എക്സ്പ്രഷൻ]

chmod

chmod ലിസ്റ്റ്

chmod() ഫംഗ്‌ഷൻ ഒരു പരാമീറ്ററായി അതിലേക്ക് അയച്ച ലിസ്റ്റിൽ പ്രതിനിധീകരിക്കുന്ന ഫയലുകളുടെ അനുമതികൾ മാറ്റുന്നു. ഈ ലിസ്‌റ്റിൻ്റെ ആദ്യ ഘടകം ഉടമയ്‌ക്കും ഉടമയുടെ ഗ്രൂപ്പിലെ ഉപയോക്താക്കൾക്കും മറ്റ് ഉപയോക്താക്കൾക്കുമുള്ള ആക്‌സസ് അവകാശങ്ങൾ വ്യക്തമാക്കുന്ന ഒരു മൂന്നക്ക ഒക്ടൽ നമ്പർ ആയിരിക്കണം. ഓരോ ഒക്ടൽ അക്കവും മുകളിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ഉപയോക്തൃ ഗ്രൂപ്പുകൾക്കായി ഫയൽ റീഡ്, ഫയൽ റൈറ്റ്, ഫയൽ എക്സിക്യൂഷൻ (ഫയൽ ഒരു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമിനെ പ്രതിനിധീകരിക്കുന്നുവെങ്കിൽ) എന്നിവ നിർവ്വചിക്കുന്നു. ബിറ്റുകൾ സജ്ജമാക്കുകഅതിൻ്റെ ബൈനറി പ്രാതിനിധ്യം ബന്ധപ്പെട്ട ഫയൽ അനുമതികളെ പ്രതിഫലിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്, മൂന്ന് ബിറ്റുകളും സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ (ഒക്ടൽ നമ്പർ 7), അനുബന്ധ ഉപയോക്തൃ ഗ്രൂപ്പിന് എല്ലാ അവകാശങ്ങളും ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു: അവർക്ക് ഫയലിൽ നിന്ന് വായിക്കാനും ഫയലിലേക്ക് എഴുതാനും അത് എക്സിക്യൂട്ട് ചെയ്യാനും കഴിയും. 6 ൻ്റെ മൂല്യം വായിക്കാനും എഴുതാനുമുള്ള അനുമതി നിർണ്ണയിക്കുന്നു, 5 ഒരു ഫയലിൽ നിന്ന് വായിക്കാനും അത് പ്രവർത്തിപ്പിക്കാനും അനുവദിക്കുന്നു, എന്നാൽ ഈ ഫയലിലേക്ക് എഴുതാൻ അനുവദിക്കുന്നില്ല. സാധാരണഗതിയിൽ, ഒരു നോൺ എക്സിക്യൂട്ടബിൾ ഫയൽ സൃഷ്ടിക്കുന്നത് ആക്സസ് മോഡ് 0666 ഉപയോഗിച്ചാണ് - എല്ലാ ഉപയോക്താക്കൾക്കും ഫയലിലേക്ക് വിവരങ്ങൾ വായിക്കാനും എഴുതാനും കഴിയും, ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ - മോഡ് 0777 ഉപയോഗിച്ച്. ഫയലിൻ്റെ ഉടമ ഫയലിലേക്ക് എഴുതുന്നത് നിയന്ത്രിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ. അവൻ്റെ ഗ്രൂപ്പ്, തുടർന്ന് ഇനിപ്പറയുന്ന പ്രസ്താവന നടപ്പിലാക്കണം:

Chmod 0664, "file.dat";

chmod() ഫംഗ്‌ഷൻ്റെ റിട്ടേൺ മൂല്യം, chown() ഫംഗ്‌ഷൻ പോലെ, ആക്‌സസ് അവകാശങ്ങൾ മാറ്റുന്നതിനുള്ള പ്രവർത്തനം വിജയകരമായി പൂർത്തിയാക്കിയ ലിസ്റ്റിലെ ഫയലുകളുടെ എണ്ണമാണ്.

ഡോസ്, വിൻഡോസ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ, ഉടമയുടെ ആക്‌സസ് മോഡുകൾ സജ്ജീകരിക്കുക മാത്രമാണ് പ്രധാനം.

ചൗൺ

ചോൺ ലിസ്റ്റ്

സ്വന്തം ഫയൽ സൃഷ്ടിക്കുന്ന ഏതൊരു ഉപയോക്താവിനെയും അതിൻ്റെ ഉടമയായി കണക്കാക്കുന്നു. chown() ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പേൾ സ്‌ക്രിപ്റ്റിൽ നിന്ന് ഫയലിൻ്റെ ഉടമയെ മാറ്റാനാകും. ഈ ഫംഗ്‌ഷൻ്റെ പാരാമീറ്റർ ഒരു ലിസ്‌റ്റാണ്, അതിൻ്റെ ആദ്യ രണ്ട് ഘടകങ്ങൾ സംഖ്യാ ഐഡൻ്റിഫയറുകൾ uid, gid എന്നിവയെ പ്രതിനിധീകരിക്കണം. ലിസ്റ്റിൽ ശേഷിക്കുന്ന ഇനങ്ങൾ ഉടമ മാറ്റുന്ന ഫയലുകളുടെ പേരുകളാണ്. ഈ ഫംഗ്‌ഷൻ ഉടമയുടെയും ഗ്രൂപ്പ് മാറ്റത്തിൻ്റെയും പ്രവർത്തനം വിജയിച്ച ഫയലുകളുടെ എണ്ണം നൽകുന്നു.

ഉദാഹരണം:

@list = (234, 3, "file1.dat", "file2.dat"); $ നമ്പർ = chown(@list); മുന്നറിയിപ്പ് "എല്ലാ ഫയലുകളുടെയും ഉടമ മാറിയിട്ടില്ല!" എങ്കിൽ $നമ്പർ != @list-2;

ഒരു ഫയലിൻ്റെ ഉടമയെ മാറ്റാൻ ഉടമയ്‌ക്കോ സൂപ്പർ യൂസർക്കോ (സാധാരണയായി ഒരു സിസ്റ്റം അഡ്മിനിസ്‌ട്രേറ്റർ) മാത്രമേ കഴിയൂ. UNIX സിസ്റ്റങ്ങൾ. ഉള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഫയൽ സിസ്റ്റം UNIX (DOS, Windows) ഒഴികെയുള്ള സിസ്റ്റങ്ങളിൽ, ഈ പ്രവർത്തനം പ്രവർത്തിക്കുന്നു, എന്നാൽ അതിൻ്റെ ക്രമീകരണങ്ങൾ ഫയലിലേക്കുള്ള ആക്‌സസിനെ ബാധിക്കില്ല.

chroot

ഉപയോക്താവിൻ്റെ പ്രോസസിൻ്റെയും അതിൻ്റെ സ്പോൺഡ് പ്രോസസുകളുടെയും എല്ലാ ആപേക്ഷിക (സ്ലാഷ് "/" ഉപയോഗിച്ച് ആരംഭിക്കുന്ന) ഫയൽനാമങ്ങൾക്കുമായി ഒരു പുതിയ റൂട്ട് ഡയറക്ടറി നിർവചിക്കുന്നു. നിലവിലുള്ള ഡയറക്‌ടറി മാറ്റില്ല. ഒരു പരാമീറ്ററിൻ്റെ അഭാവത്തിൽ, $_ എന്ന പ്രത്യേക വേരിയബിളിൻ്റെ മൂല്യം ഉപയോഗിക്കുന്നു. സൂപ്പർ യൂസർക്ക് മാത്രമേ വിളിക്കാൻ കഴിയൂ.

CHroot DIRECTORY_NAME

അടുത്ത്

DESCRIPTOR അടയ്ക്കുക

ഫയലിൻ്റെ പ്രവർത്തനം പൂർത്തിയാകുമ്പോൾ, അത് ക്ലോസ് () ഫംഗ്ഷൻ ഉപയോഗിച്ച് അടച്ചിരിക്കും. ഈ ഫംഗ്‌ഷനിലേക്കുള്ള ഏക ഓപ്‌ഷണൽ പാരാമീറ്റർ ഫയലുമായി ബന്ധപ്പെട്ട ഹാൻഡിൽ ആണ്.

I/O ബഫർ വിജയകരമായി മായ്‌ക്കുകയും സിസ്റ്റം ഫയൽ ഹാൻഡിൽ അടയ്‌ക്കുകയും ചെയ്‌താൽ ഈ ഫംഗ്‌ഷൻ True നൽകുന്നു. ഒരു പാരാമീറ്റർ ഇല്ലാതെ വിളിക്കുന്നു, ക്ലോസ് ഫംഗ്ഷൻ നിലവിലെ ഹാൻഡിലുമായി ബന്ധപ്പെട്ട ഫയലിനെ സെലക്ട് () പ്രകാരം അടയ്ക്കുന്നു.

ഫയൽ അടയ്ക്കുന്നതിൽ പിശകുകൾ സംഭവിക്കുകയാണെങ്കിൽ, പ്രത്യേക വേരിയബിൾ $!: അടയ്ക്കുക (ഫയൽ) അല്ലെങ്കിൽ ഡൈ ചെയ്യുക "ഫയൽ അടയ്ക്കുന്നതിൽ പിശക്: $!";

അടച്ചു

DESCRIPTOR പാരാമീറ്റർ വ്യക്തമാക്കിയ ഡയറക്‌ടറി ഹാൻഡിലുമായി ബന്ധപ്പെട്ട ഡയറക്‌ടറി അടയ്‌ക്കുന്നു. ഡയറക്‌ടറി വിജയകരമായി അടച്ചെങ്കിൽ True എന്ന ബൂളിയൻ മൂല്യം നൽകുന്നു.

ക്ലോസ്ഡിർ ഡിസ്ക്രിപ്റ്റർ

fcntl

Unix സിസ്റ്റം കമാൻഡ് fcntl(2) നടപ്പിലാക്കുന്നു. ഉപയോഗിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ Fcntl പ്രസ്താവന ഉപയോഗിച്ച് സിസ്റ്റം സ്ഥിരമായ നിർവചനങ്ങൾ ആക്സസ് ചെയ്യണം.

റിട്ടേൺ മൂല്യം: എങ്കിൽ സിസ്റ്റം പ്രവർത്തനം-1 നൽകുന്നു, തുടർന്ന് പേൾ ഫംഗ്‌ഷൻ നിർവചിക്കപ്പെട്ടിട്ടില്ല; സിസ്റ്റം ഫംഗ്‌ഷൻ 0 നൽകുന്നുവെങ്കിൽ, പേൾ ഫംഗ്‌ഷനിൽ "0 എന്നാൽ ട്രൂ" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു; സിസ്റ്റം ഫംഗ്‌ഷൻ മറ്റേതെങ്കിലും മൂല്യം നൽകുന്നുവെങ്കിൽ, Perl ഫംഗ്‌ഷൻ അതേ മൂല്യം നൽകുന്നു.

Fcntl DESCRIPTOR, FUNCTION, SCALAR

ഗ്ലോബ്

നൽകിയിരിക്കുന്ന പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന പേരുകൾ നിലവിലുള്ള ഡയറക്‌ടറിയിൽ കാണുന്ന ഫയലുകൾ നൽകുന്നു (Unix metacharacters "*", "?" ഉപയോഗിച്ച്). എക്‌സ്‌പ്രഷൻ്റെ മൂല്യം ഒരു ഫയൽനാമ പാറ്റേൺ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് ആയിരിക്കണം.

ഗ്ലോബ് എക്സ്പ്രഷൻ

ioctl

Unix സിസ്റ്റം കമാൻഡ് ioctl(2) നടപ്പിലാക്കുന്നു. ഉപയോഗിക്കുന്നതിന് മുമ്പ് സിസ്റ്റം സ്ഥിരമായ നിർവചനങ്ങൾ ആക്സസ് ചെയ്യണം ഓപ്പറേറ്റർ ആവശ്യമാണ്"ioctl.ph";

റിട്ടേൺ മൂല്യം:

• സിസ്റ്റം ഫംഗ്‌ഷൻ -1 നൽകുകയാണെങ്കിൽ, പേൾ ഫംഗ്‌ഷൻ നിർവചിച്ചിട്ടില്ല;
• സിസ്റ്റം ഫംഗ്‌ഷൻ 0 നൽകുന്നുവെങ്കിൽ, പേൾ ഫംഗ്‌ഷനിൽ "0 എന്നാൽ ട്രൂ" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു;
• സിസ്റ്റം ഫംഗ്‌ഷൻ മറ്റേതെങ്കിലും മൂല്യം നൽകുന്നുവെങ്കിൽ, Perl ഫംഗ്‌ഷൻ അതേ മൂല്യം നൽകുന്നു.

fcntl ഡിസ്ക്രിപ്റ്റർ, ഫങ്ഷൻ, സ്കെലാർ

ലിങ്ക്

ലിങ്ക് പഴയത്, പുതിയത്

lstat

ഒരു ഫയലിലേക്കുള്ള പ്രതീകാത്മക ലിങ്കിൻ്റെ ഐനോഡ് ഘടനയ്ക്കായി ഫീൽഡ് മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. പരാമീറ്റർ ഒഴിവാക്കിയാൽ, പ്രത്യേക വേരിയബിളിൻ്റെ മൂല്യം $_ ഉപയോഗിക്കുന്നു.

Lstat [DESCRIPTOR] lstat [EXPRESSION]

പ്രതീകാത്മക ലിങ്കുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കാൻ ഉപയോഗിക്കുന്നു. ലിങ്ക് ചെയ്യുന്ന ഫയലിനേക്കാൾ, ലിങ്കിൻ്റെ തന്നെ ഐനോഡ് ഘടനയുടെ ഫീൽഡ് മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു. ഈ ഫംഗ്‌ഷൻ സ്റ്റാറ്റ്() ഫംഗ്‌ഷന് സമാനമായി പ്രവർത്തിക്കുന്നു.

mkdir

DIRECTORY പാരാമീറ്ററിൽ വ്യക്തമാക്കിയിരിക്കുന്ന പേരും MODE പാരാമീറ്റർ നിർണ്ണയിക്കുന്ന ആക്സസ് മോഡും ഉപയോഗിച്ച് ഒരു പുതിയ ഡയറക്ടറി സൃഷ്ടിക്കുന്നു. ഡയറക്‌ടറി സൃഷ്‌ടിക്കുകയാണെങ്കിൽ, അത് ബൂളിയൻ മൂല്യം True നൽകുന്നു, അല്ലാത്തപക്ഷം False ആയും $! ഒരു പിശക് സന്ദേശം ലോഗിൻ ചെയ്‌തു.

Mkdir കാറ്റലോഗ്, മോഡ്

തുറക്കുക

DESCRIPTOR തുറക്കുക, FILE_NAME; DESCRIPTOR തുറക്കുക;

ഒരു Perl പ്രോഗ്രാമിൽ നിന്ന് ഒരു ഫയൽ ആക്സസ് ചെയ്യുന്നതിന്, ഒരു ഹാൻഡിൽ ആവശ്യമാണ്. ഒരു ഹാൻഡിൽ സൃഷ്ടിക്കാൻ ഓപ്പൺ() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. പരാമീറ്ററുകളിൽ വ്യക്തമാക്കിയ ഫയലിൻ്റെ പേരിൽ ഒരു ഓപ്പൺ ഓപ്പറേഷൻ നടത്തുമ്പോൾ, അനുബന്ധ ഫയൽ തുറക്കുകയും ഈ ഫയലിനായി ഒരു ഡിസ്ക്രിപ്റ്റർ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. നിങ്ങൾക്ക് ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്ററായി ഒരു എക്സ്പ്രഷൻ ഉപയോഗിക്കാം - അതിൻ്റെ മൂല്യം ഡിസ്ക്രിപ്റ്ററിൻ്റെ പേരായിരിക്കും. ഫയലിൻ്റെ പേര് നേരിട്ട് ഒരു സ്ട്രിംഗ് ലിറ്ററൽ അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് മൂല്യമുള്ള ഒരു എക്സ്പ്രഷൻ ആയി വ്യക്തമാക്കുന്നു. ഫയൽനാമമില്ലാത്ത ഓപ്പൺ ഓപ്പറേഷൻ, സ്കെയിലർ വേരിയബിളായ $DESCRIPTOR-ൽ അടങ്ങിയിരിക്കുന്ന ഒരു ഫയൽ തുറക്കുന്നു, ഇത് my() ഫംഗ്ഷൻ നിർവചിച്ചിരിക്കുന്ന ഒരു ലെക്സിക്കൽ വേരിയബിളാകാൻ കഴിയില്ല.

ഉദാഹരണം:

#! perl -w $var = "out.dat"; $FILE4 = "file4.dat"; FILE1, "in.dat" തുറക്കുക; # ഫയലിൻ്റെ പേര് നൽകിയിരിക്കുന്നത് തുറന്ന FILE2, $var എന്ന വരിയാണ്; # ഫയലിൻ്റെ പേര് നൽകിയിരിക്കുന്നത് വേരിയബിൾ ഓപ്പൺ FILE3, "/perlourbook/01/".$var; # ഫയലിൻ്റെ പേര് FILE4 തുറന്ന എക്‌സ്‌പ്രഷനിൽ വിലയിരുത്തപ്പെടുന്നു; # $FILE4 വേരിയബിളിലെ ഫയലിൻ്റെ പേര്

പൂർണ്ണമായ ഫയലിൻ്റെ പേര് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഉള്ള ഫയൽ നിർദ്ദിഷ്ട പേര്പേൾ പ്രോഗ്രാമിൻ്റെ അതേ ഡയറക്ടറിയിൽ സ്ഥിതി ചെയ്യുന്നു. നിങ്ങൾക്ക് പൂർണ്ണമായ ഫയലിൻ്റെ പേര് വ്യക്തമാക്കാൻ കഴിയും, എന്നാൽ ഇത് നിങ്ങൾ ഉപയോഗിക്കുന്ന ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ ആശ്രയിച്ചിരിക്കുന്നുവെന്ന് ഓർമ്മിക്കുക. ഉദാഹരണത്തിന്, വിൻഡോസിൽ നിങ്ങൾ ഡ്രൈവ് നാമം വ്യക്തമാക്കണം: d:/perlbook/file1.doc

ഏത് ഫയലും ഇനിപ്പറയുന്ന മോഡുകളിലൊന്നിൽ തുറക്കാൻ കഴിയും: ഫയലിൻ്റെ അവസാനം വായിക്കുക, എഴുതുക അല്ലെങ്കിൽ കൂട്ടിച്ചേർക്കുക. ഫയലിൻ്റെ പേരിലേക്ക് ഉചിതമായ പ്രിഫിക്സ് ചേർത്താണ് ഇത് ചെയ്യുന്നത്:

• < (чтение)
• > (റെക്കോർഡ്)
• >> (ചേർക്കുക)

പ്രിഫിക്‌സ് ഒഴിവാക്കിയാൽ, ഫയൽ സ്ഥിരസ്ഥിതിയായി റീഡ് മോഡിൽ തുറക്കും.

ഫയലിൻ്റെ തുടക്കത്തിൽ റൈറ്റ് മോഡിൽ തുറന്ന ഒരു ഫയലിലേക്ക് വിവരങ്ങൾ എഴുതുന്നു, അത് തുറക്കുന്നതിന് മുമ്പ് അതിൽ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങളുടെ നാശത്തിലേക്ക് നയിക്കുന്നു.

അനുബന്ധ മോഡിൽ തുറന്ന ഒരു ഫയലിൽ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങൾ നശിപ്പിക്കപ്പെടുന്നില്ല; ഫയലിൻ്റെ അവസാനം പുതിയ റെക്കോർഡുകൾ ചേർക്കുന്നു.

നിങ്ങൾ ഒരു ഫയൽ റൈറ്റ് അല്ലെങ്കിൽ അപ്പെൻഡ് മോഡിൽ തുറക്കുമ്പോൾ, നിർദ്ദിഷ്ട പേരുള്ള ഒരു ഫയൽ നിലവിലില്ലെങ്കിൽ, ഒന്ന് സൃഷ്ടിക്കപ്പെടും, അത് ഈ ഫയൽ തുറക്കുന്ന മോഡുകളെ റീഡ് മോഡിൽ നിന്ന് വേർതിരിക്കുന്നു, അതിൽ ഫയൽ നിലനിൽക്കണം. അല്ലെങ്കിൽ, ഓപ്പൺ ഓപ്പറേഷൻ പരാജയപ്പെടുകയും അനുബന്ധ ഹാൻഡിൽ സൃഷ്ടിക്കപ്പെടുകയും ചെയ്യുന്നില്ല.

ഒരു ഫയൽ മറ്റൊരു മോഡിൽ തുറക്കാൻ Perl നിങ്ങളെ അനുവദിക്കുന്നു - റീഡ്/റൈറ്റ് മോഡ്.

ഇത് ചെയ്യുന്നതിന്, റീഡ് പ്രിഫിക്‌സിന് മുമ്പ്<, записи >അല്ലെങ്കിൽ >> ചേർത്ത് നിങ്ങൾ ഒരു + അടയാളം ഇടണം.

• +< - сохраняют содержимое открываемого файла
• +> - ആദ്യം തുറക്കുന്ന ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ മായ്‌ക്കുന്നു
• +>> - തുറക്കുന്ന ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ സംരക്ഷിക്കുക, ഫയലിലേക്ക് എഴുതുന്നത് എല്ലായ്പ്പോഴും ഫയൽ ഉള്ളടക്കത്തിൻ്റെ അവസാനത്തിലാണ് ചെയ്യുന്നത്

ഓപ്പൺഡിർ

EXPRESS പാരാമീറ്ററിൻ്റെ മൂല്യത്തിന് തുല്യമായ ഒരു ഡയറക്ടറി തുറക്കുകയും അത് DESCRIPTOR പാരാമീറ്റർ വ്യക്തമാക്കിയ ഹാൻഡിലുമായി ബന്ധപ്പെടുത്തുകയും ചെയ്യുന്നു. ഡയറക്‌ടറി ഹാൻഡിൽ പേരുകൾ പേൾ നെയിം ടേബിളിൻ്റെ സ്വന്തം നെയിംസ്‌പെയ്‌സിൽ സൂക്ഷിച്ചിരിക്കുന്നു.

ഓപ്പൺഡിർ ഡിസ്ക്രിപ്റ്റർ, എക്സ്പ്രഷൻ

റീഡ്ലിങ്ക്

സിംബോളിക് ലിങ്കുകൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നടപ്പിലാക്കുകയാണെങ്കിൽ, EXPRESSION വ്യക്തമാക്കിയ പ്രതീകാത്മക ലിങ്കിൻ്റെ മൂല്യം നൽകുന്നു; അല്ലാത്തപക്ഷം - മാരകമായ തെറ്റ്. വീണ്ടെടുക്കുമ്പോൾ, പ്രതീകാത്മക ലിങ്ക് മൂല്യങ്ങൾ ലഭിച്ചുവെങ്കിൽ സിസ്റ്റം പിശകുകൾ, ഒരു നിർവചിക്കാത്ത മൂല്യവും പ്രത്യേക വേരിയബിളിൽ $! ഒരു പിശക് സന്ദേശം ലോഗിൻ ചെയ്‌തു. പരാമീറ്റർ ഒഴിവാക്കിയാൽ, $_ എന്ന വേരിയബിളിൻ്റെ മൂല്യം ഉപയോഗിക്കും.

റീഡ്‌ലിങ്ക് [എക്സ്പ്രഷൻ]

പേരുമാറ്റുക

ഫയലിൻ്റെ പേര് മാറ്റുന്നു. പേരുമാറ്റം വിജയകരമാണെങ്കിൽ 1 നൽകുന്നു, അല്ലാത്തപക്ഷം 0.

OLD_NAME, NEW_NAME എന്നതിൻ്റെ പേര് മാറ്റുക

സ്ഥിതിവിവരക്കണക്ക്

UNIX ഫയൽ ഘടനയിൽ, ഒരു ഫയലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ അതിൻ്റെ ഐനോഡിൽ സൂക്ഷിക്കുന്നു. ഐനോഡ് ഘടനയിൽ 13 ഫീൽഡുകൾ അടങ്ങിയിരിക്കുന്നു, ഇതിനായി പ്രത്യേക നൊട്ടേഷനുകൾ ഉപയോഗിക്കുന്നു:

ഫീൽഡ്	വിവരണം
dev	ഫയൽ സിസ്റ്റത്തിലെ ഉപകരണ നമ്പർ
ino	ഇനോഡ് നമ്പർ
മോഡ്	ഫയൽ മോഡ് (തരവും അനുമതികളും)
nlink	ഫയലിലേക്കുള്ള ഹാർഡ് ലിങ്കുകളുടെ എണ്ണം (ലിങ്കുകളുടെ അഭാവത്തിൽ 1 ന് തുല്യമാണ്)
uid	ഫയൽ ഉടമയുടെ സംഖ്യാ ഐഡൻ്റിഫയർ
gid	ഫയൽ ഉടമയുടെ സംഖ്യാ ഗ്രൂപ്പ് ഐഡി
rdev	ഉപകരണ ഐഡി (പ്രത്യേക ഫയലുകൾക്ക് മാത്രം)
വലിപ്പം	ഫയൽ വലുപ്പം ബൈറ്റുകളിൽ
ഒരു സമയം	യുഗത്തിൻ്റെ തുടക്കം മുതൽ ഫയലിലേക്കുള്ള അവസാന ആക്‌സസ് സമയം
സമയം	സമയം അവസാന മാറ്റംയുഗത്തിൻ്റെ തുടക്കം മുതൽ ഫയൽ
ctime	യുഗത്തിൻ്റെ തുടക്കം മുതൽ ഐനോഡ് മാറിയതിന് ശേഷമുള്ള സമയം
blksize	I/O പ്രവർത്തനങ്ങൾക്കായി തിരഞ്ഞെടുത്ത ബ്ലോക്ക് വലുപ്പം
ബ്ലോക്കുകൾ	ഫയൽ ഉൾക്കൊള്ളിക്കാൻ അനുവദിച്ച ബ്ലോക്കുകളുടെ യഥാർത്ഥ എണ്ണം

ലിസ്റ്റുചെയ്തിരിക്കുന്ന എല്ലാ ഐനോഡ് ഘടനാ ഫീൽഡുകളും എല്ലാ ഫയൽ സിസ്റ്റങ്ങളും പിന്തുണയ്ക്കുന്നില്ല.

ഒരു ഫയൽ ഐനോഡ് ഘടനയുടെ ഫീൽഡുകളുടെ മൂല്യങ്ങൾ നേടുന്നതിനാണ് സ്റ്റാറ്റ് () ഫംഗ്ഷൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പ്രോഗ്രാമിൽ തുറന്നിരിക്കുന്ന ഒരു ഫയലിൻ്റെ പേരോ വിവരണമോ ആകാം അതിൻ്റെ ഏക പരാമീറ്റർ. പട്ടികയിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്ന ക്രമത്തിൽ ഫയൽ ഐനോഡ് ഘടന ഫീൽഡുകളുടെ മൂല്യങ്ങൾ അടങ്ങുന്ന 13 ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ് ഇത് നൽകുന്നു.

സാധാരണ ഉപയോഗം പേൾ പ്രോഗ്രാംചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു:

($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size, $atime,$mtime,$ctime,$blksize,$blocks) = stat($filename);

ഫീൽഡ് നാമങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ഐഡൻ്റിഫയറുകളുള്ള സ്കെയിലർ വേരിയബിളുകളുടെ ഒരു ലിസ്റ്റിലേക്ക് ഫീൽഡ് മൂല്യങ്ങൾ അസൈൻ ചെയ്യുന്നത് സ്കെയിലറുകളുടെ ഒരു നിരയിലേക്ക് അസൈൻ ചെയ്യുന്നതിനേക്കാൾ പ്രോഗ്രാമിനെ കൂടുതൽ വായിക്കാനാകുന്നതാക്കുന്നു:

@ഇനോഡ് = സ്റ്റാറ്റ് ($ ഫയലിൻ്റെ പേര്);

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

stat() ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ ഒരു പരാമീറ്ററും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് $_ എന്ന പ്രത്യേക വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന ഫയലിൻ്റെ ഐനോഡിൻ്റെ ഘടന നൽകുന്നു.

ഫയൽ വിവര ഫംഗ്‌ഷൻ, ഒരു ലിസ്റ്റ് സന്ദർഭത്തിൽ വിജയകരമായി നടപ്പിലാക്കുമ്പോൾ, ഫയൽ ഐനോഡ് ഘടന ഫീൽഡ് മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു, അല്ലെങ്കിൽ ശൂന്യമായ പട്ടികപരാജയപ്പെട്ടാൽ. IN സ്കെയിലർ സന്ദർഭംഅത് അതിൻ്റെ നിർവ്വഹണ ഫലങ്ങളെ ആശ്രയിച്ച് ബൂളിയൻ മൂല്യം ശരിയോ തെറ്റോ നൽകുന്നു.

ഫയൽ വിവരങ്ങളുടെ എളുപ്പത്തിലുള്ള ഉപയോഗത്തിനായി, stat() ഫംഗ്ഷൻ, വിജയകരമായ നിർവ്വഹണത്തിൽ, ഫലമായുണ്ടാകുന്ന ഫീൽഡ് മൂല്യങ്ങൾ കാഷെ ചെയ്യുന്നു. പ്രത്യേക ഫയൽ ഡിസ്ക്രിപ്റ്റർ _ (അണ്ടർസ്കോർ) ഉപയോഗിച്ച് നിങ്ങൾ ഈ ഫംഗ്ഷൻ വിളിക്കുകയാണെങ്കിൽ, മുമ്പത്തെ കോളിൽ നിന്ന് കാഷെയിൽ സംഭരിച്ചിരിക്കുന്ന വിവരങ്ങൾ ഇത് തിരികെ നൽകും. stat()-ലേക്ക് വീണ്ടും വിളിക്കാതെയോ അതിൻ്റെ ഫലങ്ങൾ പ്രോഗ്രാം വേരിയബിളുകളിൽ സൂക്ഷിക്കാതെയോ വിവിധ ഫയൽ ആട്രിബ്യൂട്ടുകൾ പരിശോധിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഒരു ഫയലിൻ്റെ മാത്രമല്ല, അതിലേക്കുള്ള ഹാർഡ് ലിങ്കുകളുടെയും ഡയറക്ടറികളുടെയും ഐനോഡ് ഘടന നേടുന്നതിന് സ്റ്റാറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിക്കാം, കാരണം അവ ഡയറക്ടറി ഫയലുകളുടെയും അവയുടെ സംഖ്യാ ഐനോഡുകളുടെയും ഡാറ്റ ബ്ലോക്കുകളിൽ അടങ്ങിയിരിക്കുന്ന ഫയലുകൾ കൂടിയാണ്.

സിംലിങ്ക്

സിംലിങ്ക് OLD_NAME, NEW_NAME

ഉമാസ്ക്

EXPRESS (ഒക്ടൽ നമ്പർ) പാരാമീറ്ററിൻ്റെ മൂല്യം വ്യക്തമാക്കിയ പ്രോസസ്സ് ആക്സസ് മോഡ് മാസ്ക് സജ്ജീകരിക്കുകയും മുമ്പത്തെ ആക്സസ് മോഡ് മാസ്ക് മൂല്യം നൽകുകയും ചെയ്യുന്നു.

ഉമാസ്ക് എക്സ്പ്രഷൻ

അൺലിങ്ക് ചെയ്യുക

LIST പാരാമീറ്റർ വ്യക്തമാക്കിയ ഫയലുകൾ ഇല്ലാതാക്കുന്നു. വിജയകരമായി ഇല്ലാതാക്കിയ ഫയലുകളുടെ എണ്ണം നൽകുന്നു.

ലിസ്റ്റ് അൺലിങ്ക് ചെയ്യുക

സമയം

സമയ ലിസ്റ്റ്

ഫയൽ ഐനോഡ് ഘടനയിൽ, ഫയലിലേക്കുള്ള അവസാന ആക്‌സസ് (അടൈം) സമയം, ഫയലിൻ്റെ പരിഷ്‌ക്കരണം (mtime), ഐനോഡിലെ മാറ്റം (ctime) എന്നിവ സംഭരിക്കുന്ന മൂന്ന് ഫീൽഡുകൾ ഉണ്ട്. ഒരു ഫയലിൻ്റെ അവസാന ആക്‌സസിൻ്റെയും പരിഷ്‌ക്കരണത്തിൻ്റെയും സമയം മാറ്റാൻ utime() ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം. അതിൻ്റെ പാരാമീറ്റർ പ്രോസസ്സ് ചെയ്യുന്ന ഫയലുകളുടെ പേരുകൾ അടങ്ങുന്ന ഒരു ലിസ്റ്റാണ്, കൂടാതെ ലിസ്റ്റിലെ ആദ്യ രണ്ട് ഘടകങ്ങൾ ഇവയാണ് സംഖ്യാ മൂല്യങ്ങൾപുതിയ കാലം അവസാന പ്രവേശനംകൂടാതെ പരിഷ്കാരങ്ങളും:

@files = ("file1.dat", "file2.dat"); $ഇപ്പോൾ = സമയം; utime $now, $now, @files;

ഈ കോഡ് സ്‌നിപ്പറ്റ് @files ലിസ്റ്റിലെ ഫയലുകളുടെ അവസാന ആക്‌സസും പരിഷ്‌ക്കരണ സമയവും മാറ്റുന്നു വര്ത്തമാന കാലം, ടൈം ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ലഭിച്ചു.

utime() ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, ഐനോഡിൻ്റെ (ctime) അവസാന പരിഷ്ക്കരണത്തിൻ്റെ സമയവും മാറുന്നു - ഇത് നിലവിലെ സമയത്തിന് തുല്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു. റിട്ടേൺ മൂല്യം എന്നത് അവസാന ആക്‌സസും പരിഷ്‌ക്കരണ സമയമാറ്റ പ്രവർത്തനവും വിജയിച്ച ഫയലുകളുടെ എണ്ണമാണ്.

ഹോം പേജ്» പേൾ » ലൂപ്പുകളും ശാഖകളും.

ഫയൽ ഇൻപുട്ടും ഔട്ട്പുട്ടും.

ഫയൽ ഇൻപുട്ടും ഔട്ട്‌പുട്ടും ടെക്‌സ്‌റ്റ് ഫയലുകൾ വായിക്കുന്നതിനും എഴുതുന്നതിനുമുള്ള മതിയായ ഉപാധിയായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്‌തതാണ് പേൾ. എന്നിരുന്നാലും, നിങ്ങൾ പിന്നീട് പഠിക്കുന്നതുപോലെ, ക്രമരഹിതമായ ആക്സസും ബൈനറി ഫയൽ I/O ഫംഗ്ഷനുകളും പേൾ നിർവഹിക്കുന്നു. ഫയൽ പ്രവർത്തനങ്ങൾക്ക് ഒരു ഫയൽ ഹാൻഡിൽ ആവശ്യമാണ്, ഇത് ഒരു പ്രത്യേക ഫയലുമായി ബന്ധപ്പെട്ട ഒരു വേരിയബിളാണ്. ഡിഫോൾട്ടായി, ഓരോ പേൾ സ്‌ക്രിപ്റ്റിനും മൂന്ന് സ്റ്റാൻഡേർഡ് പോയിൻ്ററുകൾ ഉണ്ട്, സ്‌ക്രിപ്റ്റ് പ്രവർത്തിക്കുമ്പോൾ പേൾ സ്വയമേവ തുറക്കുന്നു: STDJN, STDOUT, STDERR. ഈ മൂന്ന് സ്റ്റാൻഡേർഡ് പോയിൻ്ററുകൾ സി പ്രോഗ്രാമിംഗ് ഭാഷയുടെ സ്റ്റാൻഡേർഡ് സ്ട്രീമുകളായ STDIN, STDOUT, STDERR എന്നിവയുമായി പൊരുത്തപ്പെടുന്നു. കൂടാതെ, Perl സ്ക്രിപ്റ്റിന് മറ്റ് നിർദ്ദിഷ്ട ഫയലുകളിലേക്ക് അധിക പോയിൻ്ററുകൾ തുറക്കാൻ കഴിയും. ഫയലുകളും മറ്റ് സ്ട്രീമുകളും തുറക്കുന്നു ഒരു സ്ക്രിപ്റ്റ് ഒരു ഫയൽ ഉപയോഗിക്കുന്നതിന്, അത് ഓപ്പൺ ഫംഗ്ഷനെ വിളിക്കണം. അവൾക്ക് ഉണ്ട് അടുത്ത കാഴ്ച: ഓപ്പൺ (ഫയൽഹാൻഡിൽ[, ഫയൽനാമം]) ഫംഗ്‌ഷനിൽ നിന്ന് വ്യത്യസ്തമായി തുറന്ന ലൈബ്രറികൾ C റൺടൈമിൽ, Perl ഓപ്പൺ ഫംഗ്‌ഷനിൽ ഫംഗ്‌ഷൻ കോളിൽ ഒരു മോഡ് പാരാമീറ്റർ അടങ്ങിയിട്ടില്ല. ഫയലിൻ്റെ പേരിനെ അടിസ്ഥാനമാക്കി ഒരു ഫയൽ തുറക്കുന്നതിനുള്ള മോഡ് Perl നിർണ്ണയിക്കുന്നു. ഫയൽ തുറക്കുന്ന മോഡും ഫയലിൻ്റെ പേരും തമ്മിലുള്ള ബന്ധം പട്ടിക 12.3 വ്യക്തമാക്കുന്നു. ഫയലിൻ്റെ പേര് ഓപ്പറേഷൻ വായിക്കാൻ മാത്രമായി ഒരു ഫയൽ തുറക്കുക (fopen പോലെ തന്നെ) FILE> എഴുതാൻ ഒരു ഫയൽ സൃഷ്‌ടിക്കുക (fopen പോലെ തന്നെ) >FILE> അവസാനം കൂട്ടിച്ചേർക്കാൻ ഒരു ഫയൽ തുറക്കുക (fopen പോലെ തന്നെ) FILE> വായിക്കാൻ ഒരു ഫയൽ സൃഷ്ടിക്കുക /write (fopen പോലെ തന്നെ) fopen) കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന പ്രക്രിയയിൽ നിന്ന് ഒരു ചാനൽ തുറക്കുക, കമാൻഡ് ടേബിൾ എക്സിക്യൂട്ട് ചെയ്യുന്ന പ്രക്രിയയിലേക്ക് ഒരു ചാനൽ തുറക്കുക. 12.3 പേൾ ഫയൽ നാമകരണവും ആക്സസ് മോഡ് കൺവെൻഷനുകളും ശ്രദ്ധിക്കുക: പൈപ്പ് സ്ട്രീം മോഡ് എല്ലാ സിസ്റ്റങ്ങളിലും നിലവിലില്ലായിരിക്കാം. ഓപ്പൺ ഫംഗ്‌ഷൻ കോളിൽ നിന്ന് ഒരു ഫയലിൻ്റെ പേര് ഒഴിവാക്കിയാൽ, ഫയലിൻ്റെ പേര് $FileHandle സ്ട്രിംഗ് വേരിയബിളിൽ അടങ്ങിയിട്ടുണ്ടെന്ന് Perl അനുമാനിക്കുന്നു. സ്ക്രിപ്റ്റ് ഫയൽ ഉപയോഗിച്ച് പൂർത്തിയാകുമ്പോൾ, താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ ക്ലോസ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് അത് ക്ലോസ് ചെയ്യുന്നു: ക്ലോസ് (ഫയൽഹാൻഡിൽ); ഓപ്പൺ, ക്ലോസ് ഫംഗ്‌ഷനുകളുടെ ഉപയോഗം ഒരു പ്രോഗ്രാം ശകലം വ്യക്തമാക്കുന്നു: open(InFile, "test.dat") || മരിക്കുക; വായിക്കാൻ # തുറക്കുക # test.dat open(OutFile, ">test.dat") || മരിക്കുക; # create test.dat $AuxFile = ">>test.dat"; തുറക്കുക(Aux, $AuxFile) || മരിക്കുക; # പൂർത്തീകരണത്തിനായി തുറക്കുന്നു # test.dat close(InFile); അടയ്ക്കുക (ഔട്ട്ഫയൽ); അടയ്ക്കുക (ഓക്സ്); ഫയൽ പോയിൻ്ററുകൾക്ക് സാധാരണ ഒരു പ്രതീക പ്രിഫിക്സുകൾ ഇല്ലെന്ന കാര്യം ശ്രദ്ധിക്കുക. നിങ്ങൾ പിന്നീട് പഠിക്കുന്നതുപോലെ, പേൾ സ്ക്രിപ്റ്റുകൾക്ക് പോയിൻ്റർ പേരുകൾ സ്കെയിലർ വേരിയബിൾ സ്ട്രിംഗുകളായി സംഭരിക്കാനും അവ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഏത് ഫംഗ്ഷനിലേക്കും പോയിൻ്റർ കൈമാറാനും കഴിയും. ആവശ്യമെങ്കിൽ Perl മൂല്യ പരിവർത്തനം നടത്തുന്നു. ഓപ്പറേഷൻ റൂമിൽ MS-DOS സിസ്റ്റംടെക്‌സ്‌റ്റ്, ബൈനറി മോഡുകൾക്കിടയിൽ മാറാൻ ഫയൽ ഇൻപുട്ട്/ഔട്ട്‌പുട്ട് അനുവദിക്കുന്ന hinmode എന്ന അധിക ഫീച്ചറിനെ പേൾ പിന്തുണയ്ക്കുന്നു. മിക്ക സിസ്റ്റങ്ങളിലും, ടെക്സ്റ്റ്, ബൈനറി മോഡുകൾ തമ്മിലുള്ള വ്യത്യാസം പ്രശ്നമല്ല. എന്നിരുന്നാലും വേണ്ടി ഓപ്പറേറ്റിംഗ് സിസ്റ്റം MS-DOS ന്യൂലൈൻ പ്രതീകം രണ്ട് പ്രതീകങ്ങളുടെ (CR+LF) ഒരു ശ്രേണിയാണ്. മിക്ക പ്രോഗ്രാമുകളും ഒരു വരിയുടെ അവസാനത്തിൽ രണ്ട് പ്രതീകങ്ങൾ കാണുമെന്ന് പ്രതീക്ഷിക്കാത്തതിനാൽ, I/O സിസ്റ്റം പരിവർത്തനം നടത്തണം. ബിൻമോഡ് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിന്, അനുബന്ധ പോയിൻ്റർ തുറക്കാൻ കഴിയും. ബിൻമോഡ് ഫംഗ്‌ഷന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്: binmode(FileHandle); ലൈൻ-ലൈൻ റീഡിംഗ് ആൻഡ് റൈറ്റിംഗ് ഡാറ്റ ഒരു ഫയലിൽ നിന്ന് ഒരു സ്ക്രിപ്റ്റ് വായിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗം ഒരു ഓപ്പറേറ്ററെ ഉപയോഗിക്കുക എന്നതാണ്. പേളിൽ, ത്രികോണ ബ്രാക്കറ്റുകളാൽ ചുറ്റപ്പെട്ട ഒരു ഫയൽ പോയിൻ്റർ ഇൻപുട്ട്-ചിഹ്നമായി മാറുന്നു. ഉദാഹരണത്തിന്, Test.dat ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ വായിക്കുന്നതിനും പ്രദർശിപ്പിക്കുന്നതിനുമുള്ള ഇൻപുട്ട് പ്രതീകത്തിൻ്റെ ഉപയോഗം ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം വ്യക്തമാക്കുന്നു. തുറക്കുക(InFile, "Test.dat") || മരിക്കുക; അതേസമയം ($ലൈൻ =) ($ലൈൻ പ്രിൻ്റ് ചെയ്യുക; # ഫയലിൽ നിന്ന് ഒരു ലൈൻ പ്രിൻ്റ് ചെയ്യുന്നു) അടയ്ക്കുക(ഇൻഫിൽ); ഇൻപുട്ട് പ്രതീകം ഫയലിൻ്റെ അവസാനത്തിൽ എത്തുമ്പോൾ, അത് തെറ്റായി നൽകുന്നു, അതായത് ഈ സാഹചര്യത്തിൽ while ലൂപ്പിൻ്റെ എക്സിക്യൂഷൻ അവസാനിപ്പിക്കുന്നു. വളരെ സവിശേഷമായതും എന്നാൽ ഉപയോഗപ്രദവുമായ ഉപയോഗമുള്ള ഒരു പ്രത്യേക (ശൂന്യമായ) ഇൻപുട്ട് പ്രതീകമുണ്ട്, സൂചിപ്പിച്ചിരിക്കുന്നു. സ്ക്രിപ്റ്റ് ആദ്യമായി ഒരു ശൂന്യമായ ഇൻപുട്ട് പ്രതീകം ഉപയോഗിക്കുമ്പോൾ, അത് ആർഗ്യുമെൻ്റുകൾ പാഴ്സ് ചെയ്യുന്നു കമാൻഡ് ലൈൻ. @ARGV സ്ട്രിംഗ് ശൂന്യമാണെങ്കിൽ, ഇൻപുട്ട് പ്രതീകം STDIN-ൽ നിന്ന് വായിക്കുന്നു. പകരം @ARGV ശൂന്യമല്ലെങ്കിൽ, @ARGV വേരിയബിളിൽ വ്യക്തമാക്കിയിട്ടുള്ള ഫയലുകളിൽ ആദ്യത്തേത് Perl തുറന്ന് ഫയലിൻ്റെ ഉള്ളടക്കം വായിക്കുന്നു. Perl ഒരു ഫയൽ പ്രോസസ്സ് ചെയ്യുന്നത് പൂർത്തിയാക്കുമ്പോൾ, അത് അടുത്തതിലേക്ക് നീങ്ങുന്നു. സ്ക്രിപ്റ്റ് എല്ലാ ഫയലുകളും വായിച്ചതിനുശേഷം, ചിഹ്നം തെറ്റ് നൽകുന്നു. ഒരു ഫയലിൻ്റെ മുഴുവൻ ഉള്ളടക്കങ്ങളും ഒരു അറേയിലേക്ക് വായിക്കാൻ പേൾ സ്ക്രിപ്റ്റുകൾക്ക് ഇൻപുട്ട് പ്രതീകം ഉപയോഗിക്കാനും കഴിയും, അങ്ങനെ ഫയലിൻ്റെ ഓരോ വരിയും അറേയുടെ ഒരു ഘടകമായി മാറുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന പ്രസ്താവന STDIN ഫയലിൽ നിന്ന് @lines അറേയിലേക്ക് വായിക്കുന്നു: @lines = ; ഒരു ഫയലിലേക്ക് ഡാറ്റ എഴുതുന്നതും വളരെ ലളിതമാണ്. വാസ്തവത്തിൽ, നിങ്ങൾ പ്രിൻ്റ് ഫംഗ്ഷൻ ഉപയോഗിക്കുമ്പോഴെല്ലാം നിങ്ങൾ ഇത് ചെയ്തു. പ്രിൻ്റ് ഫംഗ്‌ഷൻ്റെ പൂർണ്ണ ഫോർമാറ്റ് ഇപ്രകാരമാണ്: പ്രിൻ്റ് ലിസ്റ്റ്; പ്രിൻ്റ് ഫംഗ്‌ഷൻ ഒരു ഫയൽ പോയിൻ്റർ ഒരു ആർഗ്യുമെൻ്റായി എടുക്കുന്നില്ലെങ്കിൽ, അത് അതിൻ്റെ ഔട്ട്‌പുട്ട് STDOUT-ലേക്ക് അയയ്‌ക്കുന്നു. ഒരു ഔട്ട്‌പുട്ട് ഫയലിലേക്ക് ഡാറ്റ കൂട്ടിച്ചേർക്കുന്നതിനുള്ള പ്രിൻ്റ് ഫംഗ്‌ഷൻ്റെ ഉപയോഗം ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം വ്യക്തമാക്കുന്നു: open(LogFile, ">>logfile.dat") || മരിക്കുക; ############## ($m, $d, $y) = (പ്രാദേശിക സമയം(സമയം)) ; പ്രിൻ്റ് ലോഗ്ഫയൽ "ക്യാപ്റ്റൻ്റെ ലോഗ്, സ്റ്റാർഡേറ്റ് ++m$/$d/$y\n"; അടയ്ക്കുക(ലോഗ്ഫയൽ); ശ്രദ്ധിക്കുക: ഫയൽ പോയിൻ്ററും ഔട്ട്പുട്ട് ലിസ്റ്റും ഒരു കോമയാൽ വേർതിരിക്കപ്പെട്ടിട്ടില്ല. വായനയും എഴുത്തും ഡാറ്റ ബ്ലോക്കുകൾ പ്രോഗ്രാമർമാർ പലപ്പോഴും പരിഗണിക്കുന്നു ടെക്‌സ്‌റ്റ് ഫയലുകൾ ടെക്‌സ്‌റ്റ് സ്‌ട്രീമുകളായി മാറുന്നത് ഒരു പ്രതീകം മറ്റൊന്നിനെ പിന്തുടരുന്നതിനാലാണ്. സ്ഥിരമായ ഡാറ്റാ ബ്ലോക്കുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന്. sysread, syswrite ഫംഗ്‌ഷനുകൾക്ക് ഇനിപ്പറയുന്ന ഫോർമാറ്റുകളുണ്ട്: $result = sysread(FileHandle, $Var, Length[, Offset]);$result = syswrite(FileHandle, $Var, Length[, Offset]) ഫംഗ്‌ഷൻ കോൾ ഫയലിൻ്റെ (ഓഫ്‌സെറ്റ്) ആരംഭത്തിൽ നിന്ന് ഒരു ഓഫ്‌സെറ്റ് വ്യക്തമാക്കുന്നുവെങ്കിൽ, ഫംഗ്‌ഷനുകൾ അവ I/O പ്രവർത്തനങ്ങൾ ആരംഭിക്കുന്ന ലൊക്കേഷനായി തിരയും. sysread, syswrite ഫംഗ്‌ഷനുകൾ ഒരു സ്‌കെലാർ വേരിയബിൾ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നു. സ്ട്രിംഗ് തരം. ഫംഗ്ഷനുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനാൽ നിശ്ചിത ബ്ലോക്കുകൾ മെമ്മറി, ഡാറ്റയിൽ പൂജ്യങ്ങളും ഫയലിൻ്റെ എൻഡ് മാർക്കറുകളും ഉൾപ്പെടെ ബൈനറി മൂല്യങ്ങൾ അടങ്ങിയിരിക്കാം. ഫംഗ്‌ഷൻ കോൾ ഫയലിൻ്റെ (ഓഫ്‌സെറ്റ്) ആരംഭത്തിൽ നിന്ന് ഒരു ഓഫ്‌സെറ്റ് വ്യക്തമാക്കുന്നുവെങ്കിൽ, ഫംഗ്ഷൻ ഐ/ഒ പ്രവർത്തനങ്ങൾ നടത്താൻ തുടങ്ങുന്ന ഫയലിലെ സ്ഥലത്തിനായി തിരയുന്നു. നിങ്ങൾ ഡാറ്റ ബ്ലോക്കുകൾ ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, സ്ക്രിപ്റ്റുകൾക്ക് ഇനിപ്പറയുന്ന I/O ഫംഗ്ഷനുകളും ഉപയോഗിക്കാം: $result = search(FileHandle, Position, Base); $ ഫലം = പറയുക (ഫയൽ ഹാൻഡിൽ); $ഫലം = eof(FileHandle); സീക്ക് ഫംഗ്‌ഷൻ സി റൺടൈം ലൈബ്രറി ഫംഗ്‌ഷൻ fseek പോലെ തന്നെ പ്രവർത്തിക്കുന്നു, പൊസിഷൻ പാരാമീറ്റർ ഉത്ഭവവുമായി ബന്ധപ്പെട്ട സ്ഥാനം വ്യക്തമാക്കുന്നു, അത് ബേസ് പാരാമീറ്റർ ഇനിപ്പറയുന്ന രീതിയിൽ വ്യക്തമാക്കുന്നു: ? 0 ഫയലുകളുടെ തുടക്കം മുതൽ തിരയണോ? 1 നിലവിലെ സ്ഥാനത്ത് നിന്ന് തിരയണോ? 2 ഫയലിൻ്റെ അറ്റത്ത് നിന്ന് കണ്ടെത്തുന്നത്, സി റൺടൈം ലൈബ്രറിയുടെ ഫ്‌റ്റെൽ ഫംഗ്‌ഷൻ പോലെ തന്നെ പെർളിൻ്റെ ടെൽ ഫംഗ്‌ഷൻ പ്രവർത്തിക്കുന്നു.ഈ ഫംഗ്‌ഷൻ ഒരു റീഡ് അല്ലെങ്കിൽ റൈറ്റ് ഓപ്പറേഷൻ നടത്തുന്ന ഫയലിലെ നിലവിലെ സ്ഥാനം നൽകുന്നു. അവസാനമായി, eof ഫംഗ്‌ഷൻ, C ഫംഗ്‌ഷൻ feof പോലെ, ഫയലിൻ്റെ അവസാനത്തിൽ എത്തിയോ എന്ന് നിർണ്ണയിക്കാൻ സ്‌ക്രിപ്റ്റിന് ഉപയോഗിക്കാവുന്ന ഒരു മൂല്യമോ മൂല്യമോ നൽകുന്നു. ബൈനറി ഡാറ്റ പ്രോസസ്സിംഗ്, പേൾ പ്രാഥമികമായി ടെക്സ്റ്റ് പ്രോസസ്സിംഗിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നുണ്ടെങ്കിലും, ഇതിന് ബൈനറി ഡാറ്റ പ്രോസസ്സ് ചെയ്യാനും കഴിയും. സ്‌ക്രിപ്റ്റുകൾക്ക് സ്ട്രിംഗ് വേരിയബിളുകൾ ഉപയോഗിച്ച് ബൈനറി ഡാറ്റ ചങ്കുകളായി നീക്കാനും sysread, syswrite ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് ബൈറ്റ് I/O പ്രവർത്തനങ്ങൾ നടത്താനും കഴിയും. എന്നിരുന്നാലും, ഡാറ്റ ഉപയോഗിച്ച് എന്തും ചെയ്യുന്നതിനായി, സ്ക്രിപ്റ്റ് ഡാറ്റയെ അതിൻ്റെ സ്കെയിലർ ഫോർമാറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യാൻ നിർബന്ധിതരാകുന്നു. ബൈനറി ഡാറ്റ സംഭരിക്കുന്നു ഒരു പേൾ സ്ക്രിപ്റ്റ് sysread ഫംഗ്ഷൻ ഉപയോഗിച്ച് ബൈനറി ഡാറ്റയുടെ ഒരു ബ്ലോക്ക് വായിക്കുമ്പോൾ, അത് ആ ബൈനറി ഡാറ്റ ഒരു സ്കെയിലർ സ്ട്രിംഗ് വേരിയബിളിൽ സംഭരിക്കുന്നു. ഡാറ്റ എന്താണെന്ന് പേൾ ശ്രദ്ധിക്കുന്നില്ല, അതിൽ nulls അല്ലെങ്കിൽ ASCII അല്ലാത്ത മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഒരു പ്രതീക സ്ട്രിംഗിനുള്ളിൽ, പേൾ ബൈറ്റുകളെ ബൈറ്റുകളായി സ്വീകരിക്കുന്നു. സിയിൽ നിന്ന് വ്യത്യസ്തമായി, പേൾ നൾ ടെർമിനേറ്റഡ് സ്ട്രിംഗുകൾ ഉപയോഗിക്കുന്നില്ല. ഡാറ്റ ASCII കോഡ് ടേബിളുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ, ഏത് ടെക്‌സ്‌റ്റും പോലെ സ്‌ക്രിപ്റ്റിന് ഇത് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. എന്നാൽ ഡാറ്റ ഒരു ബൈനറി മൂല്യമാണെങ്കിൽ, പേളിന് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് സ്ക്രിപ്റ്റ് അത് അൺപാക്ക് ചെയ്യണം. ബൈനറി ഡാറ്റ പേൾ വേരിയബിളുകളിലേക്ക് അൺപാക്ക് ചെയ്യുന്നു ബൈനറി ഡാറ്റ ആക്‌സസ് ചെയ്യുന്നതിന് ഒരു സ്‌ക്രിപ്റ്റിന്, അത് അതിൻ്റെ സ്വന്തം സ്‌കെലാർ ഫോർമാറ്റിലേക്ക് അൺപാക്ക് ചെയ്യണം. അൺപാക്ക് ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് പേൾ സ്ക്രിപ്റ്റുകൾ ഡാറ്റ അൺപാക്ക് ചെയ്യുന്നു, അതിന് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് ഉണ്ട്: $result = അൺപാക്ക് (ടെംപ്ലേറ്റ്, എക്സ്പ്രഷൻ); എക്സ്പ്രഷൻ എന്നത് ഒരു സാധാരണ സ്ട്രിംഗ് വേരിയബിളാണ്, അത് sysread ഫംഗ്ഷൻ വായിക്കുന്ന ബൈനറി ഡാറ്റ കൈവശം വയ്ക്കുന്നു, എന്നാൽ ഒരു സ്ട്രിംഗ് ആയി വ്യാഖ്യാനിക്കേണ്ട ഒരു എക്സ്പ്രഷൻ ആകാം. എക്സ്പ്രഷൻ ഓപ്പറണ്ടിലെ മൂല്യങ്ങളെ എങ്ങനെ വ്യാഖ്യാനിക്കാമെന്ന് വിവരിക്കുന്ന ഒരു പ്രതീക ടെംപ്ലേറ്റ് സ്ട്രിംഗ് ആണ് ടെംപ്ലേറ്റ്. ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം അൺപാക്ക് ഫംഗ്‌ഷൻ്റെ ഉപയോഗം വ്യക്തമാക്കുന്നു: ($r, $g, $b) = unpack("C3", $color);# 3 പ്രതീകങ്ങളായി അൺപാക്ക് ചെയ്യും @longwords = unpack("L*", $ ഡാറ്റ); നീളമുള്ള # വാക്കുകളുടെ ഒരു ലിസ്റ്റിലേക്ക് # അൺപാക്ക് ചെയ്യുന്നു @സ്റ്റഫ് = അൺപാക്ക് ("S2L", $bin); # 2 ഷോർട്ട്സുകളിലേക്കും നീളമുള്ളതിലേക്കും അൺപാക്ക് ചെയ്യും, പാറ്റേണിലെ ഓരോ പ്രതീകത്തിനും ശേഷം ആ പ്രതീകം എത്ര തവണ ഉപയോഗിക്കണമെന്ന് സൂചിപ്പിക്കുന്ന ഒരു നമ്പർ നൽകാം. ഒരു സംഖ്യയ്ക്ക് പകരം ഒരു നക്ഷത്രചിഹ്നം (*) ഉണ്ടെങ്കിൽ, വരിയിൽ ശേഷിക്കുന്ന എല്ലാ ഡാറ്റയ്ക്കും പ്രവർത്തനം നടത്തും. നമ്പർ നൽകിയിട്ടില്ലെങ്കിൽ, അത് ഒരിക്കൽ നടത്തുന്നു. സ്ക്രിപ്റ്റിന് ടെംപ്ലേറ്റ് സ്‌ട്രിംഗിൽ എത്ര പാറ്റേൺ പ്രതീകങ്ങൾ വേണമെങ്കിലും ഉൾപ്പെടുത്താം. സ്ട്രിംഗ് പാരാമീറ്റർ ടെംപ്ലേറ്റിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങൾ പട്ടിക 12.4 പട്ടികപ്പെടുത്തുന്നു, ഒപ്പം അവ ഓരോന്നിനും അൺപാക്ക് ഫംഗ്‌ഷൻ്റെ നിർവ്വഹണത്തിൽ ചെലുത്തുന്ന ഫലത്തിൻ്റെ വിവരണവും. പാറ്റേൺ ചിഹ്ന വിവരണം എ ASCII സ്ട്രിംഗ്അസാധുവായ പ്രതീകം ഇല്ലാതെ A ASCII സ്ട്രിംഗ് b ബിറ്റ് സ്ട്രിംഗ് (LSB ആദ്യം) B ബിറ്റ് സ്ട്രിംഗ് (MSB ആദ്യം) c സിംഗിൾ-ബൈറ്റ് ഒപ്പിട്ട പ്രതീകം C സിംഗിൾ-ബൈറ്റ് ഒപ്പിടാത്ത പ്രതീകം d ഇരട്ട കൃത്യതയുള്ള ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യം ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യം , സിംഗിൾ-പ്രിസിഷൻ പാറ്റേൺ h ഹെക്സാഡെസിമൽ മൂല്യങ്ങളുടെ സ്ട്രിംഗ് (ലോ-ഓർഡർ ബിറ്റുകൾ ആദ്യം വരുന്നു) H ഹെക്സാഡെസിമൽ മൂല്യങ്ങളുടെ സ്ട്രിംഗ് (ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റുകൾ ആദ്യം വരുന്നു) i ഒപ്പിട്ട പൂർണ്ണസംഖ്യ I ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ l ദൈർഘ്യമുള്ള L ൻ്റെ ഒപ്പിട്ട പൂർണ്ണസംഖ്യ സമാനമാണ്, എന്നാൽ ഒപ്പിടാത്ത n ഹ്രസ്വ പൂർണ്ണസംഖ്യ N നീളമുള്ള പൂർണ്ണസംഖ്യ p പോയിൻ്റർ to string s ഷോർട്ട് സൈൻ ചെയ്ത പൂർണ്ണസംഖ്യ S ഹ്രസ്വ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ u സ്ട്രിംഗ് ഡീകോഡിംഗ് v ഹ്രസ്വ പൂർണ്ണസംഖ്യ V നീണ്ട പൂർണ്ണസംഖ്യ x മുന്നോട്ട് ഒരു ബൈറ്റ് ഒഴിവാക്കുക X പിന്നിലേക്ക് ഒരു ബൈറ്റ് ഒഴിവാക്കുക @ സ്ട്രിംഗ് ടാബിലെ നിർദ്ദിഷ്ട സ്ഥാനത്തേക്ക് പോകുക. 12.4 ടെംപ്ലേറ്റ് ചിഹ്നങ്ങൾ ഡാറ്റ ബൈനറി സ്ട്രിംഗുകളിലേക്ക് പാക്ക് ചെയ്യുന്നു ബൈനറി ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുന്നതിന്, സ്ക്രിപ്റ്റ് സ്കെയിലർ മൂല്യങ്ങൾ ബൈനറി പ്രതീക സ്ട്രിംഗുകളിലേക്ക് പാക്ക് ചെയ്യണം. ഇത് ചെയ്യുന്നതിന്, പാക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കുക, അതിൻ്റെ ഫോർമാറ്റ് ചുവടെ കാണിച്ചിരിക്കുന്നു: $ഫലം = പാക്ക് (ടെംപ്ലേറ്റ്, ലിസ്റ്റ്); ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം പായ്ക്ക് ഫംഗ്‌ഷൻ്റെ ഉപയോഗം വ്യക്തമാക്കുന്നു: $color = pack("C3", $r, $g, $b); $ഡാറ്റ = പാക്ക് ("L*", @longword); $ ബിൻ = പായ്ക്ക് ("S2L", @സ്റ്റഫ്); പാക്ക് ഫംഗ്‌ഷൻ അൺപാക്ക് ഫംഗ്‌ഷൻ്റെ അതേ പാറ്റേൺ പ്രതീകങ്ങൾ ഉപയോഗിക്കുന്നു, ഒരു പ്രതീകങ്ങൾ ഒഴികെ. A, u, x, x, @. ഡയറക്‌ടറികൾക്കൊപ്പം പ്രവർത്തിക്കുന്നത് പേൾ വിപുലമായ ഫയൽ കൈകാര്യം ചെയ്യൽ ഫംഗ്‌ഷനുകൾ മാത്രമല്ല, ചിലതും നൽകുന്നു സൗകര്യപ്രദമായ പ്രവർത്തനങ്ങൾഡയറക്ടറികൾ സ്കാൻ ചെയ്യുന്നതിനായി. ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ ഡയറക്‌ടറികളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ചില പ്രധാന പ്രവർത്തനങ്ങൾ ഞങ്ങൾ വിശദമായി പരിശോധിക്കും. ഡയറക്‌ടറികൾ തുറക്കുന്നതും വായിക്കുന്നതും അടയ്ക്കുന്നതും ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ തുറക്കാനും വായിക്കാനും പേൾ സ്‌ക്രിപ്റ്റുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. അതുപോലെ, ഈ സ്ക്രിപ്റ്റുകൾ ഡയറക്ടറികൾ തുറക്കുകയും അവയിൽ അടങ്ങിയിരിക്കുന്ന സ്ലൈഡുകളുടെ പേരുകൾ വായിക്കുകയും ചെയ്യുന്നു. ഒരു ഡയറക്ടറി തുറക്കാൻ, സ്ക്രിപ്റ്റുകൾ ഓപ്പൺഡിർ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു, ഡയറക്ടറി പോയിൻ്ററും അതിലേക്കുള്ള പാതയും കടന്നുപോകുന്നു. ഒരു ഡയറക്ടറിയിൽ അടങ്ങിയിരിക്കുന്ന ഫയലുകളുടെ ഒരു ലിസ്റ്റ് വായിക്കാൻ, സ്ക്രിപ്റ്റ് readdir ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. അവസാനമായി, ഡയറക്ടറി അടയ്ക്കുന്നതിന് ക്ലോസ്ഡർ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. നിലവിലെ ഡയറക്‌ടറിയിൽ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് readdir ഫംഗ്‌ഷൻ്റെ ഉപയോഗം ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം വ്യക്തമാക്കുന്നു: opendir(Dir, $INC) || മരിക്കുക; അതേസമയം ($file = readdir(Dir)) ( പ്രിൻ്റ് "$file \n" ) closeir(Dir); ഈ സ്‌നിപ്പെറ്റ് $INC ഫോർമാറ്റ്, ലിസ്റ്റ് എന്ന വേരിയബിൾ ഉപയോഗിക്കുന്നു; $ഫലം = sprintf(ഫോർമാറ്റ്, ലിസ്റ്റ്); സ്ഥിരസ്ഥിതിയായി, printf ഫംഗ്‌ഷൻ ഫോർമാറ്റ് ചെയ്‌ത ഔട്ട്‌പുട്ട് സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് STDIO-ലേക്ക് അയയ്‌ക്കുന്നു, ഒപ്പം സ്‌പ്രിൻ്റ്എഫ് ഫംഗ്‌ഷൻ ഫോർമാറ്റ് ചെയ്‌ത സ്‌ട്രിംഗും നൽകുന്നു. രണ്ട് സാഹചര്യങ്ങളിലും, സ്ട്രിംഗ് ഫോർമാറ്റ് സി ഭാഷാ ഫംഗ്‌ഷനുകൾക്ക് ഏതാണ്ട് സമാനമാണ്, അല്ലാതെ പേൾ ഭാഷാ ഫംഗ്‌ഷനുകൾ നീളം സ്‌പെസിഫയറിനെ (*) പിന്തുണയ്ക്കുന്നില്ല. ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം printf, sprintf ഫംഗ്‌ഷനുകളുടെ ഉപയോഗം വ്യക്തമാക്കുന്നു. $പ്രിസിഷൻ = 2; $pi = 3.1415; printf("%.2f\n", $pi); # പ്രിൻ്റ് ചെയ്യും 3.14 printf("%.$(പ്രിസിഷൻ)f", $pi); # ഒരു പേൾ ഭാഷാ സ്‌ക്രിപ്റ്റിൽ നിന്ന് 3.14 കോളിംഗ് എക്‌സ്‌റ്റേണൽ പ്രോഗ്രാമുകൾ പ്രിൻ്റ് ചെയ്യും, ഒരർത്ഥത്തിൽ ഒരു പകരക്കാരനാണ് ഷെൽ സ്ക്രിപ്റ്റുകൾഎക്‌സ്‌റ്റേണൽ പ്രോഗ്രാമുകൾ വിളിക്കുന്നത് ഉൾപ്പെടെയുള്ള സിസ്റ്റം ഇൻ്ററാക്ഷനുള്ള പിന്തുണ പേൾ ​​നൽകുന്നു. ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ നിന്ന് ബാഹ്യ പ്രോഗ്രാമുകളെ വിളിക്കുന്നതിനുള്ള നിരവധി മാർഗങ്ങൾ ചർച്ചചെയ്യുന്നു പേൾ സ്ക്രിപ്റ്റുകൾ. എന്നിരുന്നാലും, സ്ക്രിപ്റ്റുകൾ എക്സിക്യൂട്ട് ചെയ്യാൻ അനുവദിക്കുന്നത് ഓർക്കുക സിസ്റ്റം കമാൻഡുകൾ, അതുവഴി നിങ്ങളുടെ നോഡിൻ്റെ സുരക്ഷാ സംവിധാനത്തിൽ നിങ്ങൾ വിടവുകൾ തുറക്കുന്നു. പാലിക്കരുത് എന്ന പൊതു നിയമം പാലിക്കുക ബാഹ്യ ടീമുകൾഒരു പേൾ സ്ക്രിപ്റ്റിൽ നിന്ന്. എന്നിരുന്നാലും, നിങ്ങൾ ഒരു സ്ക്രിപ്റ്റിൽ നിന്ന് ബാഹ്യ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യണമെങ്കിൽ, ഈ ആവശ്യങ്ങൾക്കായി നിങ്ങൾക്ക് ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ സിസ്റ്റം, എക്സിക് അല്ലെങ്കിൽ ഫോർക്ക് ഉപയോഗിക്കാം. റെഗുലർ എക്സ്പ്രഷനുകൾ ഈ അധ്യായത്തിലുടനീളം, സ്ട്രിംഗുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഫംഗ്‌ഷനുകളുടെ ഉദാഹരണങ്ങൾ നിങ്ങൾ കണ്ടിട്ടുണ്ട്. അവയിൽ പലതും റെഗുലർ എക്സ്പ്രഷൻസ് എന്ന ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പേൾ സ്ക്രിപ്റ്റുകൾ വിപുലമായി ഉപയോഗിക്കുന്നു പതിവ് ഭാവങ്ങൾടെക്സ്റ്റ് പ്രോസസ്സിംഗിനായി. പതിവ് പദപ്രയോഗങ്ങൾ നിങ്ങൾക്ക് പുതിയതാണെങ്കിൽ, വിഷമിക്കേണ്ട. ചുരുങ്ങിയ സമയത്തിനുള്ളിൽ, നിങ്ങൾ ഈ അധ്യായത്തിൻ്റെ ഏതാനും ഭാഗങ്ങളിലൂടെ കടന്നുപോയ ശേഷം, പതിവ് പദപ്രയോഗങ്ങൾ ലളിതവും മനസ്സിലാക്കാൻ എളുപ്പവുമാകും. റെഗുലർ എക്സ്പ്രഷനുകളുടെ അവലോകനം റെഗുലർ എക്സ്പ്രഷനുകൾ ഉത്ഭവിച്ച ഒരു ഫാൻസി പദമാണ് കമ്പ്യൂട്ടർ സയൻസ്ചിഹ്നങ്ങൾ അടങ്ങുന്ന ഒരു പാറ്റേൺ നിർദ്ദേശിക്കാൻ സേവിക്കുന്നു. ഇൻപുട്ട് ഡാറ്റയെ കഷണങ്ങളായി വിഭജിച്ച് പാഴ്‌സ് ചെയ്യാൻ പേൾ സ്‌ക്രിപ്റ്റുകൾ പ്രതീകാത്മക പാറ്റേണുകൾ ഉപയോഗിക്കുന്നു. പലപ്പോഴും ഒരു സ്‌ക്രിപ്റ്റിന് സ്‌പെയ്‌സുകൾ, കോമകൾ, ടാബുകൾ, മറ്റ് ഡിലിമിറ്ററുകൾ എന്നിവയെ അടിസ്ഥാനമാക്കി ഇൻപുട്ട് പാഴ്‌സ് ചെയ്യാൻ കഴിയും. എന്നാൽ ഇൻപുട്ട് ഡാറ്റയ്ക്ക് ഒരു അനിയന്ത്രിതമായ ഫോർമാറ്റ് ഉള്ളപ്പോൾ, പതിവ് എക്സ്പ്രഷനുകൾ ഈ ടാസ്ക്കിനെ നന്നായി നേരിടും. റെഗുലർ എക്സ്പ്രഷൻ സിൻ്റാക്സ് റെഗുലർ എക്സ്പ്രഷനുകളുടെ വലിപ്പം കുറയ്ക്കാൻ, പേൾ പ്രത്യേക പ്രതീകങ്ങൾ ഉപയോഗിക്കുന്നു. സാധാരണ എക്സ്പ്രഷനുകളിൽ പേൾ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കുന്ന ചില പ്രതീകങ്ങൾ പട്ടിക 12.6 പട്ടികപ്പെടുത്തുന്നു. ചിഹ്ന വിവരണം. ഏതെങ്കിലും പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു (ന്യൂലൈൻ ഒഴികെ) (..) ഘടകങ്ങളുടെ ഒരു ശ്രേണി ഗ്രൂപ്പുചെയ്യുന്നു + മുമ്പത്തെ പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നു അല്ലെങ്കിൽ വലിയ അളവ് ഒരിക്കല്? പാറ്റേൺ പൂജ്യമോ ഒരു തവണയോ പൊരുത്തപ്പെടുന്നു * പാറ്റേണുമായി ഒന്നോ പൂജ്യമോ തവണ പൊരുത്തപ്പെടുന്നു [...] തന്നിരിക്കുന്ന സെറ്റിൽ നിന്നുള്ള ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു [^...] നിഷേധത്തിലൂടെ ലഭിച്ച സെറ്റിൽ നിന്നുള്ള ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു (...|...| ...) ബദലുകളിൽ ഒന്നുമായി പൊരുത്തപ്പെടുന്നു ^ സ്‌ട്രിംഗിൻ്റെ തുടക്കവുമായി പൊരുത്തപ്പെടുന്നു $ സ്‌ട്രിംഗിൻ്റെ അവസാനത്തിലുള്ള പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നു (n, m) പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നു n മുതൽ m തവണ വരെ (n) പാറ്റേണുമായി കൃത്യമായി n തവണ പൊരുത്തപ്പെടുന്നു (n, ) പാറ്റേണുമായി n തവണയെങ്കിലും പൊരുത്തപ്പെടുന്നു \n\t മുതലായവ. ന്യൂലൈൻ, ടാബ് മുതലായവ പൊരുത്തപ്പെടുത്തുന്നു. \b ഒരു പദ അതിർത്തിയിൽ പൊരുത്തപ്പെടുന്നു \B പദത്തിൻ്റെ അതിരുകൾക്കുള്ളിൽ പൊരുത്തപ്പെടുന്നു \d ഒരു അക്കവുമായി പൊരുത്തപ്പെടുന്നു \D ഒരു അക്കവുമായി പൊരുത്തപ്പെടുന്നു \s ഒരു സ്‌പെയ്‌സുമായി പൊരുത്തപ്പെടുന്നു \S ഒരു നോൺ-സ്‌പെയ്‌സുമായി പൊരുത്തപ്പെടുന്നു \w ഒരു അക്ഷരവുമായി പൊരുത്തപ്പെടുന്നു അല്ലെങ്കിൽ അക്കം \W അക്ഷരമോ അക്കമോ അല്ലാത്ത ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു ടാബ്. 12.6 പതിവ് പദപ്രയോഗങ്ങളിൽ ഉപയോഗിക്കുന്ന പ്രതീകങ്ങൾ, Perl സ്ഥിരമായ പദപ്രയോഗങ്ങൾ (പാറ്റേണുകൾ) സ്ലാഷുകളിൽ സ്ഥാപിക്കുന്നു, അതായത്, സ്ലാഷുകളിൽ, ഉദാഹരണത്തിന്, /pattern/ എന്ന രൂപത്തിൽ. ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം പേൾ റെഗുലർ എക്‌സ്‌പ്രഷനുകൾ ചിത്രീകരിക്കുന്നു: # ഇനിപ്പറയുന്ന റെഗുലർ എക്സ്പ്രഷനുകൾ ശരിയാണ്: /ig/ # സ്‌ട്രിംഗിൽ "ig" /(b|d|f)ig/ # സ്‌ട്രിംഗിൽ "ബിഗ്", "ഡിഗ്" അല്ലെങ്കിൽ "ഫിഗ് എന്നിവ അടങ്ങിയിരിക്കുന്നു. " /+/ # സ്‌ട്രിംഗിൽ ഒരു സംഖ്യ അടങ്ങിയിരിക്കുന്നു /*/ # സ്‌ട്രിംഗിൽ ഒരു ഐഡൻ്റിഫയർ അടങ്ങിയിരിക്കുന്നു, ഈ പദപ്രയോഗങ്ങൾ നിങ്ങൾക്ക് അർത്ഥശൂന്യമാണെന്ന് തോന്നുന്നുവെങ്കിൽ, വിഷമിക്കേണ്ട. ഈ അധ്യായത്തിൽ നമ്മൾ നിരവധി പതിവ് പദപ്രയോഗങ്ങൾ നോക്കാൻ പോകുന്നു. തൽക്കാലം, മുകളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, രണ്ട് ഫോർവേഡ് സ്ലാഷുകൾക്കിടയിൽ പെർൾ പതിവ് പദപ്രയോഗങ്ങൾ നൽകുന്നുവെന്ന് ഓർക്കുക. കീവേഡുകൾ തിരയുന്നതിന് റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്നത് സ്ട്രിംഗ് താരതമ്യങ്ങൾ എളുപ്പമാക്കുന്നതിന് പേൾ സ്ക്രിപ്റ്റുകൾ പതിവ് എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്നു. ഒരു സ്‌ട്രിംഗിൽ തന്നിരിക്കുന്ന പാറ്റേൺ അടങ്ങിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കാൻ, സ്‌ക്രിപ്റ്റിന് ഇതുപോലുള്ള പതിവ് എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കാം: എങ്കിൽ ($str =~ /pattern/) ഈ സാഹചര്യത്തിൽ, സ്‌ട്രിംഗിൽ ($str) പാറ്റേൺ കണ്ടെത്തിയോ എന്ന് റെഗുലർ എക്‌സ്‌പ്രഷനുകൾ വിലയിരുത്തുന്നു. . സ്ട്രിംഗിൽ ഒരു പാറ്റേൺ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, എക്സ്പ്രഷൻ ഒരു മൂല്യം നൽകുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന എക്സ്പ്രഷൻ ഒരു സ്ട്രിംഗിൽ വെബ് പ്രോഗ്രാമിംഗ് എന്ന വാചകം ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു: എങ്കിൽ ($str =~ /വെബ് പ്രോഗ്രാമിംഗ്/) ഒരു കൃത്യമായ പൊരുത്തം പരിശോധിക്കുന്നതിന്, എക്സ്പ്രഷൻ സ്ട്രിംഗിൻ്റെ തുടക്കത്തിലും അവസാനത്തിലും താരതമ്യം ചെയ്യണം. ഉദാഹരണത്തിന്, $str വേരിയബിൾ മൂന്ന് മൂല്യങ്ങളിൽ ഒന്ന് എടുത്താൽ മാത്രം, ഇനിപ്പറയുന്ന എക്സ്പ്രഷന് ഒരു മാഗ്നിറ്റ്യൂഡ് മൂല്യമുണ്ട്: ,) : ($str =~ /^ba(na) (2,4)$/) അതുപോലെ, ഇനിപ്പറയുന്നവ $str എന്നതിൽ ഒരു വാക്ക് അടങ്ങിയിട്ടുണ്ടെങ്കിലും മറ്റൊരു വാക്കിൻ്റെ ഭാഗമല്ലെങ്കിൽ മാത്രം ശരി എന്ന പദപ്രയോഗം. ($str =~ /\bthe\b/) ഇൻപുട്ട് വിശകലനം ചെയ്യുന്നതിന് റെഗുലർ എക്സ്‌പ്രഷനുകൾ ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ പേൾ സ്ക്രിപ്റ്റുകൾ കൂടുതൽ സങ്കീർണ്ണമാകുമ്പോൾ, ഒരു പാറ്റേൺ ഒരു സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കുന്നതിനേക്കാൾ കൂടുതൽ അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന നിരവധി സമയങ്ങൾ ഉണ്ടാകും. ഉദാഹരണത്തിന്, ഒരു നിർദ്ദിഷ്‌ട സ്ട്രിംഗ് മൂല്യം വീണ്ടെടുക്കാൻ നിങ്ങൾക്ക് ഒരു സ്‌ക്രിപ്റ്റ് ആവശ്യമായി വന്നേക്കാം. ഒരു സാധാരണ എക്‌സ്‌പ്രഷനിൽ () പ്രതീകങ്ങൾ ഗ്രൂപ്പുചെയ്യുന്നതിലൂടെ, സ്‌ക്രിപ്റ്റിന് ഒരു സ്‌ട്രിംഗിൽ നിന്ന് പൊരുത്തപ്പെടുന്ന മൂല്യങ്ങൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യാനും അവയുടെ ഒരു ലിസ്റ്റ് രൂപപ്പെടുത്താനും കഴിയും. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന പ്രോഗ്രാം ശകലം ഒരു ലിസ്റ്റിൽ നിന്ന് മാസങ്ങളും ദിവസങ്ങളും വർഷങ്ങളും എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യുന്നതിന് പതിവ് പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കുന്നു: $str = "ജനുവരി 1, 1997, "; ($m, $d, $y) = $str =~ /\s*(\S*)\s + (\d+)\D + (\d(4))/; ഈ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് സാധാരണ പദപ്രയോഗങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ വായിക്കാം: ആദ്യം എന്തെങ്കിലും ഒഴിവാക്കുക പ്രത്യേക സ്വഭാവം; ? എല്ലാ നോൺ-സ്പെഷ്യൽ പ്രതീകങ്ങളും $m വേരിയബിളിലേക്ക് എഴുതുക (മാസങ്ങളെ പ്രതിനിധീകരിക്കുന്നതിനുള്ള ഒരു വേരിയബിൾ); ? പ്രത്യേക സ്വഭാവം ഒഴിവാക്കുക; ? എല്ലാ നമ്പറുകളും $d എന്ന വേരിയബിളിൽ ഇടുക (ദിവസങ്ങൾ റെക്കോർഡ് ചെയ്യുന്നതിനുള്ള വേരിയബിൾ); ? അക്കങ്ങളല്ലാത്ത എല്ലാ പ്രതീകങ്ങളും ഒഴിവാക്കുക; ? $y വേരിയബിളിലേക്ക് നാല് അക്കങ്ങൾ എഴുതുക (വർഷങ്ങളെ പ്രതിനിധീകരിക്കുന്നതിനുള്ള ഒരു വേരിയബിൾ). ഫലത്തിൻ്റെ നിഷേധം ചേർക്കുന്ന (=~) ഓപ്പറേറ്റർ ഉപയോഗിച്ച് പാറ്റേൺ പൊരുത്തപ്പെടുത്തലിൻ്റെ മറ്റൊരു രൂപത്തെയും പേൾ പിന്തുണയ്ക്കുന്നു: (!~). ഈ ഓപ്പറേറ്റർ പദപ്രയോഗത്തിന് തുല്യമാണ്!($str =~/പാറ്റേൺ/). സ്ട്രിംഗുകൾ തിരയുന്നതിനും മാറ്റിസ്ഥാപിക്കുന്നതിനുമുള്ള പതിവ് പദപ്രയോഗങ്ങൾ ഇതുവരെ, നിങ്ങൾ പാറ്റേൺ-മാച്ചിംഗ് ഓപ്പറേറ്റർമാരെ ഉപയോഗിച്ചു. പരീക്ഷിക്കുന്ന സ്ട്രിംഗ് വേരിയബിളിനെ പരിഷ്‌ക്കരിക്കുന്ന മറ്റ് രണ്ട് റെഗുലർ എക്‌സ്‌പ്രഷനുകളെ പേൾ പിന്തുണയ്‌ക്കുന്നുവെന്ന് ഇത് മാറുന്നു. ഇനിപ്പറയുന്ന പ്രസ്താവനയിൽ, പാറ്റേണുമായി പൊരുത്തപ്പെടുന്ന സ്ട്രിംഗിൻ്റെ ഭാഗം പേൾ മാറ്റിസ്ഥാപിക്കുന്നു നൽകിയ ചരട്: $str =~ s/pattern/replacement/; ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന പ്രസ്താവന ഈ വാക്കിനെ മാറ്റിസ്ഥാപിക്കും: $str =~ s/\bcolour\b/color/; ഒരു ചെറിയ പരിഷ്ക്കരണം നിങ്ങളെ എല്ലാ വാക്കുകളും മാറ്റിസ്ഥാപിക്കാൻ അനുവദിക്കുന്നു: $str =~ s/\bcolour\b/color/g; ഈ സാഹചര്യത്തിൽ, ഗ്ലോബൽ സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിക്കാൻ പദപ്രയോഗത്തിൻ്റെ അവസാനത്തിലുള്ള g പേളിനോട് പറയുന്നു. ഐ സഫിക്സ് ഉപയോഗിച്ച്, തിരയൽ കേസ് സെൻസിറ്റീവ് ആണെന്ന് നിങ്ങൾക്ക് വ്യക്തമാക്കാം. ഒരു പാറ്റേൺ പൊരുത്തം പരിശോധിക്കുന്നതിന് വിരുദ്ധമായി, ഇനിപ്പറയുന്ന എക്സ്പ്രഷൻ മാറ്റിസ്ഥാപിക്കുന്നു: $str =~ tr/SearchList/ReplacementList/; ഉദാഹരണത്തിന്, എല്ലാ ചെറിയക്ഷരങ്ങളും ഒരേ പ്രതീകങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു വലിയക്ഷരംഈ രീതിയിൽ നടപ്പിലാക്കാം: $str =~ tr/a-z/A-Z/; # കേസ് താഴെ നിന്ന് മുകളിലേക്ക് മാറ്റുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണം നിങ്ങൾക്കായി വിശകലനം ചെയ്യുക: $letters = "abcde"; പ്രിൻ്റ് "$അക്ഷരങ്ങൾ\n" # പ്രിൻ്റ് abcde $letters =~ tr/a-z/A-Z/; പ്രിൻ്റ് "$അക്ഷരങ്ങൾ\n" # പ്രിൻ്റുകൾ എബിസിഡിഇ സംഗ്രഹം ഈ അധ്യായം പേൾ പ്രോഗ്രാമിംഗിനെക്കുറിച്ചുള്ള ഒരു ആമുഖം നൽകുന്നു. ഇവിടെ ചർച്ച ചെയ്ത ആശയങ്ങൾ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് സങ്കീർണ്ണമായി എഴുതാം CGI സ്ക്രിപ്റ്റുകൾപേർളിൽ. CGI സ്ക്രിപ്റ്റുകൾ Perl-ൽ പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവ് നേടാൻ അടുത്ത അധ്യായം നിങ്ങളെ സഹായിക്കും. സ്വന്തം സെർവർ. തുടരുന്നതിന് മുമ്പ്, ഇനിപ്പറയുന്ന പ്രധാന ആശയങ്ങൾ നിങ്ങൾ മനസ്സിലാക്കുന്നുവെന്ന് ഉറപ്പാക്കുക: വെബിനും ഇൻ്റർനെറ്റിനുമായി സ്ക്രിപ്റ്റുകൾ എഴുതാൻ പ്രോഗ്രാമർമാർ ഉപയോഗിക്കുന്ന ഒരു വ്യാഖ്യാന പ്രോഗ്രാമിംഗ് ഭാഷയാണ് പേൾ. ? Perl ൻ്റെ നിർമ്മിതികൾ പല കാര്യങ്ങളിലും C യുടെ ഘടനയോട് സാമ്യമുള്ളതാണ്, എന്നാൽ C-യിൽ കണ്ടെത്താൻ പ്രയാസമുള്ള സ്ട്രിംഗുകളും ഫയലുകളും കൈകാര്യം ചെയ്യുന്നതിന് Perl നിരവധി അധിക സവിശേഷതകൾ വാഗ്ദാനം ചെയ്യുന്നു. വെബിനും ഇൻ്റർനെറ്റിനുമായി സിജിഐ പ്രോഗ്രാമുകൾ എഴുതുന്നതിനുള്ള പ്രാഥമിക ഭാഷയാണ് പേൾ, പ്രാഥമികമായി അതിൻ്റെ വഴക്കവും ഒതുക്കമുള്ള ശൈലിയും ഉയർന്ന സുരക്ഷയും കാരണം. പേളിനെക്കുറിച്ചുള്ള വിവരങ്ങൾക്കുള്ള അവശ്യ വെബ് സൈറ്റുകൾ Pcrl ഭാഷ, അതിൻ്റെ സ്ക്രിപ്റ്റുകൾ, കൂടാതെ നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള വിശദാംശങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ കണ്ടെത്താൻ ഇനിപ്പറയുന്ന വെബ് സൈറ്റുകൾ നിങ്ങളെ സഹായിക്കും പ്രത്യേക വിവരങ്ങൾപേൾ 5 ഭാഷാ ഉറവിടങ്ങളെയും അതിൻ്റെ ലൈബ്രറികളെയും കുറിച്ച്. നിങ്ങളുടെ തിരയലിനുള്ള ഒരു ആരംഭ പോയിൻ്റായി ഈ വെബ്‌സൈറ്റുകൾ ഉപയോഗിക്കുക. http://www.shareware.com/top/Source-Code-table.html - SHAREWARE.COM - ഏറ്റവും കൂടുതൽ ജനപ്രിയ ഫയലുകൾപ്രോഗ്രാം കോഡുകൾ ഉപയോഗിച്ച്. http://www.inxpress.net:80/~moewes/computer/perl95.html - Windows 95-നുള്ള Perl. http://www.mit.edu:8001/perl/perlapi.html - PERLAPI http://www. .genome.wi.mit.edu:80/ftp/pub/software/WWW/cgi_docs.html - CGI.pm - Perl5.CGI ലൈബ്രറി http://www.metronet.com/0/perlinfo/perl5/manual/perl .html - PERL http://www.teleport.com/~rootbeer/perl.html - പേൾ പഠിക്കുന്നവർക്കുള്ള ലിങ്കുകൾ

ഫയൽ തരത്തിൽ പ്രവർത്തിക്കാൻ വേരിയബിൾ ഫയൽ ഡിസ്ക്രിപ്റ്റർ എന്ന സാങ്കേതികത പേൾ ഉപയോഗിക്കുന്നു.

ഒരു ഫയലിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നതിനോ എഴുതുന്നതിനോ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളുടെ ഉപയോഗം ആവശ്യമാണ്.

ഒരു ഫയൽ ഹാൻഡിൽ (ഫയൽ ഹാൻഡിൽ) എന്നത് I/O കണക്ഷനുകളുടെ പേരാണ്.

പേൾ മൂന്ന് ഫയലുകൾ ഹാൻഡിലുകൾ നൽകുന്നു: STDIN, STDOUT, STDERR, സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിനെ പ്രതിനിധീകരിക്കുന്നു, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്കൂടാതെ സ്റ്റാൻഡേർഡ് പിശക് ഔട്ട്പുട്ടും.

Perl ഫയലുകൾ ഇനിപ്പറയുന്ന രീതിയിൽ തുറക്കാൻ കഴിയും:

FILEHANDLE തുറക്കുക, EXPR FILEHANDLE sysopen FILEHANDLE, FILENAME, MODE, PERMS sysopen FILEHANDLE, FILENAME, മോഡ് തുറക്കുക

പാരാമീറ്റർ വിവരണം:

• EXPR: ഒരു എക്സ്പ്രഷൻ അടങ്ങുന്ന ഫയലിൻ്റെ പേരും ഫയൽ ആക്സസ് തരവും.
• മോഡ്: ആക്സസ് ഫയൽ തരം.
• കേളിംഗ്: ആക്സസ് ബിറ്റ് (ആക്സസ് റൈറ്റ്സ് ബിറ്റുകൾ).

ഓപ്പൺ ഫംഗ്ഷൻ

റീഡ്-ഒൺലി മോഡ് തുറക്കാൻ ഞങ്ങൾ ഇനിപ്പറയുന്ന കോഡ് ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു (<), чтобы открыть файл file.txt:

തുറക്കുക(DATA,"

<Только для വായനപ്രകടനം.

ഒരു ഫയൽ വായിക്കാൻ കോഡ് ഫയൽ DATA ഹാൻഡിൽ ഉപയോഗിക്കുന്നു, ഇനിപ്പറയുന്ന ഉദാഹരണം ഫയലും ഫയലിൻ്റെ ഉള്ളടക്കവും ഔട്ട്പുട്ടായി തുറക്കും:

#!/usr/bin/perl open(DATA, " )( "$_" അച്ചടിക്കുക; )

file.txt തുറക്കുന്നതിനുള്ള ഒരു മാർഗം (>) എഴുതുക എന്നതാണ് ഇനിപ്പറയുന്ന കോഡ്:

(DATA, ">file.txt") തുറക്കുക അല്ലെങ്കിൽ "file.txt 文件无法打开, $!" മരിക്കുക;

> റെക്കോർഡിംഗ് മോഡിനായി.

നിങ്ങൾക്ക് ഒരു ഫയൽ റീഡ്-റൈറ്റ് മോഡിൽ തുറക്കണമെങ്കിൽ, മുമ്പ് > അല്ലെങ്കിൽ<символ знак +, чтобы добавить:

തുറക്കുക(DATA, "+

നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫോർമാറ്റ് നീക്കംചെയ്യണമെങ്കിൽ യഥാർത്ഥ ഫയലിൻ്റെ ഉള്ളടക്കം ഈ സമീപനം നീക്കം ചെയ്യുന്നില്ല:

DATA തുറക്കുക, "+>file.txt" അല്ലെങ്കിൽ ഡൈ "file.txt 文件无法打开, $!";

നിങ്ങൾക്ക് അധിക ഡാറ്റയും മുമ്പ് അധിക ഡാറ്റയും സമർപ്പിക്കണമെങ്കിൽ, നിങ്ങൾ ഫയൽ അനുബന്ധ മോഡിൽ തുറന്നാൽ മതി:

തുറക്കുക(DATA,">>

>> നിലവിലുള്ള ഒരു ഫയലിലേക്ക് ഡാറ്റ കൂട്ടിച്ചേർക്കുന്നതിനെ പ്രതിനിധീകരിക്കുന്നു, കൂട്ടിച്ചേർക്കാൻ ഫയലിൻ്റെ ഉള്ളടക്കം വായിക്കണമെങ്കിൽ, ഒരു + ചിഹ്നം ചേർക്കുക:

തുറക്കുക(DATA,"+>>file.txt") || മരിക്കുക "file.txt 文件无法打开, $!";

ഇനിപ്പറയുന്ന പട്ടിക പട്ടികകൾ വിവിധ മോഡുകൾപ്രവേശനം:

മോഡ്	വിവരണം
<Или г
> അല്ലെങ്കിൽ
>> അല്ലെങ്കിൽ	എഴുതുന്നതിനായി ഫയൽ പോയിൻ്റർ ഫയലിൻ്റെ അവസാനം തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്നു.
+ <Или г +
+> അല്ലെങ്കിൽ w +	വായിക്കാനും എഴുതാനും തുറക്കുക, ഫയൽ പോയിൻ്റർ ഫയൽ ഹെഡറിലാണ്, ഫയൽ വലുപ്പം പൂജ്യമായി ചുരുക്കിയിരിക്കുന്നു. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്നു.
>> + അല്ലെങ്കിൽ +	ഫയലിൻ്റെ അവസാനം വരെ ഫയൽ പോയിൻ്റർ വായിക്കാനും എഴുതാനും തുറക്കുക. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്നു.

SysOpen പ്രവർത്തനം

ഫംഗ്ഷൻ SysOpen ഓപ്പൺ ഫംഗ്‌ഷന് സമാനമാണ്, എന്നാൽ അവ ഒരേ തരത്തിലുള്ള ആർഗ്യുമെൻ്റല്ല.

ഇനിപ്പറയുന്ന ഉദാഹരണം വായനയും എഴുത്തും അടിസ്ഥാനമാക്കിയുള്ളതാണ് (+<имя файла) способ, чтобы открыть файл:

Sysopen(DATA, "file.txt", O_RDWR);

ഫയൽ ഇതുപോലെ എഴുതുന്നതിന് മുമ്പ് ഇല്ലാതാക്കിയ ഫയലുകൾ നിങ്ങൾക്ക് അപ്ഡേറ്റ് ചെയ്യണമെങ്കിൽ:

Sysopen(DATA, "file.txt", O_RDWR|O_TRUNC);

ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് O_CREAT ഉപയോഗിക്കാം, O_WRONLY റൈറ്റ് ഒൺലി മോഡ്, O_RDONLY റീഡ് ഒൺലി മോഡ്.

സൃഷ്‌ടിച്ചതിന് ശേഷം, സ്ഥിരസ്ഥിതിയായി ഫയൽ അനുമതികൾ എന്തൊക്കെയാണെന്ന് ചുരുളൻ ഓപ്ഷനുകൾ ഒക്ടൽ പ്രോപ്പർട്ടി മൂല്യം സൂചിപ്പിക്കുന്നു 0x666.

ഇനിപ്പറയുന്ന പട്ടിക സാധ്യമായ മോഡ് മൂല്യങ്ങൾ പട്ടികപ്പെടുത്തുന്നു:

മോഡ്	വിവരണം
O_RDWR	വായിക്കാനും എഴുതാനും തുറക്കുക, ഫയൽ ഹെഡറിലെ ഫയൽ പോയിൻ്റർ.
O_RDONLY	ഫയൽ ഹെഡറിൽ റീഡ്-ഒൺലി ഫയൽ പോയിൻ്റർ തുറക്കുക.
ഓ_തെറ്റായി	ഫയൽ ഹെഡറിൽ ഫയൽ പോയിൻ്റർ എഴുതാൻ തുറക്കുക, ഫയൽ വലുപ്പം പൂജ്യമായി ചുരുക്കിയിരിക്കുന്നു. ഫയൽ നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കാൻ ശ്രമിക്കുന്നു.
O_CREAT	ഒരു ഫയൽ സൃഷ്ടിക്കുക
O_APPEND	ഫയൽ കൂട്ടിച്ചേർക്കുക
O_TRUNC	ഫയലിൻ്റെ വലുപ്പം പൂജ്യമായി മുറിച്ചു
O_EXCL	നിങ്ങൾ O_CREAT ഫയൽ ഉപയോഗിക്കുകയാണെങ്കിൽ, അത് ഒരു പിശക് സന്ദേശം നൽകുന്നു, ഫയൽ നിലവിലുണ്ടോ എന്ന് അതിന് പരിശോധിക്കാൻ കഴിയും
O_NONBLOCK	നോൺ-ബ്ലോക്ക് ചെയ്യുന്ന I/O ഓപ്പറേഷനുകൾ, അതിനാൽ ഞങ്ങൾ ഒന്നുകിൽ വിജയിക്കുക അല്ലെങ്കിൽ തടയാതെ തന്നെ ഒരു പിശക് ഉടനടി നൽകുക.

പ്രവർത്തനം അടയ്ക്കുക

ഒരു ഫയലിൽ ഉപയോഗിച്ചുകഴിഞ്ഞാൽ, ഇൻപുട്ട്, ഔട്ട്പുട്ട് ബഫറുകൾ അപ്ഡേറ്റ് ചെയ്യേണ്ട ഫയൽ അടയ്ക്കുക. ഫയൽ അടയ്ക്കുന്നതുമായി ബന്ധപ്പെട്ട ഫയൽ ഡിസ്ക്രിപ്റ്ററിന് ഇനിപ്പറയുന്ന വാക്യഘടനയുണ്ട്:

FILEHANDLE അടയ്ക്കുക

നിർദ്ദിഷ്‌ട ഫയൽ ഹാൻഡിലിനായുള്ള FILEHANDLE, വിജയകരമായി അടച്ചാൽ, ശരിയാണെന്ന് തിരികെ നൽകും.

അടയ്ക്കുക(ഡാറ്റ) || മരിക്കുക "无法关闭文件";

ഫയലുകൾ വായിക്കുകയും എഴുതുകയും ചെയ്യുന്നു

ഒരു ഫയലിലേക്ക് വിവരങ്ങൾ വായിക്കുന്നതിനും എഴുതുന്നതിനും നിരവധി വ്യത്യസ്ത മാർഗങ്ങളുണ്ട്:

ഓപ്പറേറ്റർ

ഒരു തുറന്ന ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ നിന്ന് വിവരങ്ങൾ വായിക്കുന്നതിനുള്ള അടിസ്ഥാന രീതി ഓപ്പറേറ്റർ. ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ, അത് ഫയൽ ഡിസ്ക്രിപ്റ്ററിൽ നിന്ന് ഒരൊറ്റ വരി നൽകുന്നു. ഉദാഹരണത്തിന്:

#!/usr/bin/perl പ്രിൻ്റ് "本教程网址?\n"; $പേര് = ; പ്രിൻ്റ് "网址:$name\n";

മുകളിലുള്ള നടപടിക്രമം നടപ്പിലാക്കിയ ശേഷം ഇനിപ്പറയുന്ന വിവരങ്ങൾ, ഞങ്ങൾ ഔട്ട്‌പുട്ട് URL പ്രിൻ്റ് സ്റ്റേറ്റ്‌മെൻ്റ് നൽകുന്നു:

നമ്മൾ എപ്പോഴാണ് ഉപയോഗിക്കുന്നത് ഒരു ലിസ്റ്റിലെ ഓരോ ലൈനിനും ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ നൽകുന്ന ഓപ്പറേറ്റർ, ഉദാഹരണത്തിന് നമുക്ക് എല്ലാ വരികളും ഒരു അറേയിലേക്ക് ഇറക്കുമതി ചെയ്യാൻ കഴിയും.

നടപ്പിലാക്കൽ ഇനിപ്പറയുന്ന രീതിയിൽ import.txt ഫയൽ സൃഷ്ടിക്കുന്നു:

$ cat import.txt 1 2 3

#!/usr/bin/perl open(DATA," ; @ലൈനുകൾ പ്രിൻ്റ് ചെയ്യുക; # 输出数组内容 അടയ്ക്കുക(ഡാറ്റ);

EOSC പ്രവർത്തനം

നിങ്ങൾ ഒരു റിവേഴ്‌സ് STDIN വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ xgetc ഫംഗ്‌ഷൻ നിർദ്ദിഷ്ട FILEHANDLE-ൽ നിന്ന് ഒരു പ്രതീകം നൽകുന്നു:

Getc FILEHANDLE getc

ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, അല്ലെങ്കിൽ ഫയൽ ഡിസ്ക്രിപ്റ്റർ ഫയലിൻ്റെ അവസാനത്തിലാണെങ്കിൽ, അത് UNDF നൽകുന്നു.

വായനാ പ്രവർത്തനം

ഫയൽ ബഫറിൽ നിന്ന് വായിച്ച വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് റീഡ് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.

ഒരു ഫയലിൽ നിന്ന് ബൈനറി ഡാറ്റ വായിക്കാൻ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.

FILEHANDLE, SCALAR, LENGTH, OFFSET വായിക്കുക FILEHANDLE, SCALAR, LENGTH എന്നിവ വായിക്കുക

പാരാമീറ്റർ വിവരണം:

• FILEHANDLE: ഒരു ഫയലിനായി ഒരു അദ്വിതീയ ഐഡൻ്റിഫയർ സംഭരിക്കാൻ ഉപയോഗിക്കുന്ന ഫയൽ ഹാൻഡിലുകൾ.
• സ്കെയിലർ: സ്ഥാനം വായിക്കാൻ ആരംഭിക്കുക.
• ദൈർഘ്യം: വായനാ ഉള്ളടക്കത്തിൻ്റെ ദൈർഘ്യം.
• ഓഫ്സെറ്റ്: ഓഫ്സെറ്റ്.

വിജയകരമാണെങ്കിൽ, വായിച്ച ബൈറ്റുകളുടെ എണ്ണം വായിക്കാൻ മടങ്ങുക, UNDEF റിട്ടേൺ പിശക് സംഭവിച്ചാൽ ഫയലിൻ്റെ അവസാനമാണെങ്കിൽ 0 നൽകുന്നു.

പ്രിൻ്റ് ഫംഗ്ഷൻ

ഫയൽ ഡിസ്ക്രിപ്റ്റർ ഫംഗ്ഷനുകളിൽ നിന്ന് വായിക്കുന്ന എല്ലാ വിവരങ്ങൾക്കും, പ്രധാന ഫംഗ്ഷൻ്റെ പിൻഭാഗം പ്രിൻ്റ് എഴുതുക എന്നതാണ്:

പ്രിൻ്റ് FILEHANDLE LIST പ്രിൻ്റ് ലിസ്റ്റ് പ്രിൻ്റ്

ഫയൽ, പ്രിൻ്റ് ഫംഗ്‌ഷനുകൾ എന്നിവ ഉപയോഗിച്ച് എക്‌സിക്യൂഷൻ ഫലങ്ങൾ ഔട്ട്‌പുട്ട് ഉപകരണങ്ങളിലേക്ക് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും (STDOUT: സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട്), ഉദാഹരണത്തിന്:

"ഹലോ വേൾഡ്!\n" അച്ചടിക്കുക;

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

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ഞങ്ങൾ നിലവിലുള്ള ഫയൽ file1.txt തുറക്കുകയും അത് ഓരോ വരിയും file2.txt-ലേക്ക് വായിക്കുകയും ചെയ്യുന്നു:

#!/usr/bin/perl # 只读方式打开文件 open(DATA1, " file2.txt"); # 拷贝数据 അതേസമയം( ) ( DATA2 $_ അച്ചടിക്കുക;) അടയ്ക്കുക(DATA1); അടയ്ക്കുക (DATA2);

ഫയലിൻ്റെ പേരുമാറ്റുക

ചുവടെയുള്ള ഉദാഹരണങ്ങൾ, ഞങ്ങൾ ഇതിനകം നിലവിലുള്ള ഫയൽ file1.txt-നെ file2.txt എന്ന് പുനർനാമകരണം ചെയ്യുന്നു, /usr/w3big/test/-ൽ വ്യക്തമാക്കിയ ഡയറക്‌ടറി:

#!/usr/bin/perl പുനർനാമകരണം ("/usr/w3big/test/file1.txt", "/usr/w3big/test/file2.txt");

ഫംഗ്ഷൻ പുനർനാമകരണത്തിന് രണ്ട് പാരാമീറ്ററുകൾ മാത്രമേ എടുക്കൂ, നിലവിലുള്ള ഫയൽ മാത്രമേ പുനർനാമകരണം ചെയ്യപ്പെടുകയുള്ളൂ.

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

ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങൾ ഞങ്ങൾ ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കുന്നു എന്ന് കാണിക്കുന്നു ഈ ഫയൽ നീക്കം ചെയ്യാൻ UNLINK:

#!/usr/bin/perl അൺലിങ്ക് ("/usr/w3big/test/file1.txt");

ഫയൽ സ്ഥാനം വ്യക്തമാക്കുക

നിങ്ങൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം ഫയൽ ലൊക്കേഷൻ ലഭിക്കുന്നതിന് പറയുക കൂടാതെ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഫയലിലെ സ്ഥാനം വ്യക്തമാക്കുക തിരയുക:

പ്രവർത്തനം പറയുക

ഫയൽ ലൊക്കേഷൻ ലഭിക്കാൻ ടെൽ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:

FILEHANDLE പറയുക

FILEHANDLE ആണെങ്കിൽ ഫംഗ്‌ഷൻ ഫയൽ ഹാൻഡിൽ സ്ഥാനം ബൈറ്റുകളിൽ നൽകുന്നു. നിങ്ങൾ സ്ഥിരസ്ഥിതി വ്യക്തമാക്കിയില്ലെങ്കിൽ ഫയൽ ഹാൻഡിലിലേക്ക് മടങ്ങും.

തിരയൽ പ്രവർത്തനം

ഫയൽ ഫയൽ ഹാൻഡിൽ റീഡ് ആൻഡ് റൈറ്റ് പോയിൻ്ററിലൂടെ ഫയൽ റീഡ് ആൻഡ് റൈറ്റ് ബൈറ്റുകളിൽ ഫയൽ വായിക്കുന്നതിനോ എഴുതുന്നതിനോ ഉള്ള പാതയിലേക്ക് നീങ്ങാൻ സീക്ക്() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:

FILEHANDLE, POSITION, WHENCE എന്നിവ അന്വേഷിക്കുക

പാരാമീറ്റർ വിവരണം:

• FILEHANDLE: ഒരു ഫയലിനായി ഒരു അദ്വിതീയ ഐഡൻ്റിഫയർ സംഭരിക്കാൻ ഉപയോഗിക്കുന്ന ഫയൽ ഹാൻഡിലുകൾ.
• സ്ഥാനം: നീക്കാനുള്ള ഫയൽ ഡിസ്ക്രിപ്റ്റർ ബൈറ്റുകളുടെ (റീഡ്-റൈറ്റ് പൊസിഷൻ പോയിൻ്റർ) എണ്ണം വ്യക്തമാക്കുന്നു.
• FROM: ഒരു ഫയൽ ഹാൻഡിൽ പ്രതിനിധീകരിക്കുന്നു (ലൊക്കേഷൻ പോയിൻ്ററുകൾ വായിക്കുന്നതിനും എഴുതുന്നതിനും) ആരംഭിക്കുമ്പോൾ ആരംഭിക്കുമ്പോൾ, നിങ്ങൾക്ക് മൂല്യം 0, 1 എടുക്കാം; ഫയലിൻ്റെ ആരംഭം, നിലവിലെ സ്ഥാനം, ഫയലിൻ്റെ അവസാനം എന്നിവ സൂചിപ്പിക്കുക.

സീക്ക് ഡാറ്റ, 256, 0;

ഫയൽ വിവരങ്ങൾ

Perl ഫയൽ പ്രവർത്തനങ്ങൾക്ക് ഒരു ഫയൽ നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കാനും വായിക്കാനും എഴുതാനും കഴിയും.

ഇതുപോലുള്ള ഒരു file1.txt ഫയൽ സൃഷ്ടിക്കാൻ എനിക്ക് എന്തുചെയ്യാൻ കഴിയും:

$ cat file1.txt www..txt"; എൻ്റെ (@വിവരണം, $size); എങ്കിൽ (-e $file) ( പുഷ് @വിവരണം, "是一个二进制文件" എങ്കിൽ (-B_); പുഷ് @വിവരണം, "是一个socket(套接字)" എങ്കിൽ (-S _); പുഷ് @വിവരണം, "是一个文本文件" എങ്കിൽ (-T _); പുഷ് @വിവരണം, "是一个特殊块文件") എങ്കിൽ പുഷ് @വിവരണം, "是一个特殊字符文件" എങ്കിൽ (-c _); പുഷ് @വിവരണം, "是一个目录" എങ്കിൽ (-d _); പുഷ് @വിവരണം, "文件存在" പുഷ്) എങ്കിൽ (-x); @വിവരണം, (($size = -s _)) ? "$size 字节" : "空"; "$file 信息：", join(", ",@description),"\n"; )

മുകളിലുള്ള പ്രോഗ്രാം, ഔട്ട്പുട്ട്:

File1.txt 信息;

ഇനിപ്പറയുന്ന പട്ടികയിൽ ടെസ്റ്റ് പ്രസ്താവനകൾ ഫയൽ ചെയ്യുക:

ഓപ്പറേറ്റർമാർ	വിവരണം
-എ	ആദ്യ തവണ റിവേഴ്സൽ ഫയൽ (യൂണിറ്റുകൾ: ദിവസങ്ങൾ)
-ബി	ഇതൊരു ബൈനറി ഫയലാണോ
- കൂടെ	ഫയൽ (ഇനോഡ്) ഐനോഡ് പരിഷ്‌ക്കരണ സമയം (യൂണിറ്റ്: ദിവസങ്ങൾ)
-എം	അവസാനം പരിഷ്കരിച്ച സമയ ഫയൽ (യൂണിറ്റ്: ദിവസങ്ങൾ)
- കുറിച്ച്	എല്ലാ ഫയലുകളും യഥാർത്ഥ യുഐഡികളാണ്
-ആർ	യഥാർത്ഥ UID/GID ഉപയോഗിച്ച് ഫയലോ ഡയറക്ടറിയോ വായിക്കാൻ കഴിയും
-എസ്	സോക്കറ്റ്
-ടി	ഇതൊരു ടെക്സ്റ്റ് ഫയലാണോ
-ഡബ്ല്യു	ഒരു ഫയലോ ഡയറക്ടറിയോ യഥാർത്ഥ യുഐഡി/ജിഐഡിയിൽ എഴുതാം
-എക്സ്	യഥാർത്ഥ യുഐഡി/ജിഐഡി വഴി ഫയലുകളോ ഡയറക്ടറികളോ തിരിച്ചറിയാൻ കഴിയും
-ബി	ബ്ലോക്ക്-സ്പെഷ്യൽ ഫയൽ (സ്പെഷ്യൽ ബ്ലോക്ക്) (ഉദാഹരണത്തിന്, ഡിസ്ക് മൗണ്ട്)
- കൂടെ	പ്രതീക-പ്രത്യേക (പ്രത്യേക പ്രതീകങ്ങൾ) ഫയൽ (ഇൻപുട്ട്/ഔട്ട്പുട്ട് ഉപകരണങ്ങൾ പോലുള്ളവ)
-ഡി	കാറ്റലോഗ്
-ഇ	ഫയലിൻ്റെയോ ഡയറക്ടറിയുടെയോ പേര് നിലവിലുണ്ട്
-എഫ്	സാധാരണ ഫയൽ
-ജി	ഫയലിനോ ഡയറക്ടറിക്കോ ഒരു സെറ്റ്ജിഡ് ആട്രിബ്യൂട്ട് ഉണ്ട്
-കെ	ഫയലിനോ ഡയറക്ടറിക്കോ ഒരു സ്റ്റിക്കി ബിറ്റ് ഉണ്ട്
-എൽ	ഇതൊരു പ്രതീകാത്മക ലിങ്കാണ്
-ഒ	എല്ലാ ഫയലുകളും യുഐഡി വഴി ആക്‌സസ് ചെയ്യാവുന്നതാണ്
-പി	ഫയൽ ഒരു പൈപ്പ് (FIFO) ആണ്
-ആർ	ഫയലുകൾ ഫലപ്രദമായി UID/GID റീഡ് ചെയ്യാൻ കഴിയും
-എസ്	ഫയലോ ഡയറക്ടറിയോ നിലവിലുണ്ട്, അത് 0 അല്ല (ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു)
-ടി	TTY ഫയൽ കൈകാര്യം ചെയ്യുക (ഇസാറ്റി സിസ്റ്റം() ഫംഗ്‌ഷൻ ഫലം നൽകുന്നു, ഫയലിൻ്റെ പേര് ഈ ടെസ്റ്റ് ഉപയോഗിക്കാൻ കഴിയില്ല)
-യു	ഫയലിനോ ഡയറക്ടറിക്കോ ഒരു സെറ്റൂയിഡ് ആട്രിബ്യൂട്ട് ഉണ്ട്
-ഡബ്ല്യു	ഫയലുകൾ ഒരു സാധുവായ UID/GID-ലേക്ക് എഴുതാം
-x	UID/GID ഉപയോഗിച്ച് ഫയലുകൾ കാര്യക്ഷമമായി നടപ്പിലാക്കാൻ കഴിയും
-z	ഫയൽ നിലവിലുണ്ട്, വലിപ്പം 0 (ഡയറക്‌ടറി സ്ഥിരാങ്കം തെറ്റാണ്), അതായത് ഫയൽ ശൂന്യമാണോ,

ഒരു ഫയൽ എന്താണെന്നതിനെക്കുറിച്ച് എഴുതേണ്ട ആവശ്യമില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, പക്ഷേ പേളിലെ ലേഖനത്തിൻ്റെ തലക്കെട്ടിൽ നിന്ന് കാണാൻ കഴിയുന്നതുപോലെ അവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്തുചെയ്യാനാകുമെന്ന് നിങ്ങൾ ചിന്തിക്കേണ്ടതുണ്ടെന്ന് ഞാൻ കരുതുന്നു. ശരി, നമുക്ക് ആരംഭിക്കാം ...

ഈ ലേഖനത്തിൽ നമ്മൾ ചർച്ച ചെയ്യും:

ഫയൽ കൃത്രിമത്വം

ഒരു ഫയലിലെ വരികളുമായി പ്രവർത്തിക്കുന്നു

എന്താണ് ഫയൽ മാനിപ്പുലേറ്ററുകൾ, അവ എന്തിനുവേണ്ടിയാണ് ഉപയോഗിക്കുന്നത്?

ഫയൽ മാനിപ്പുലേറ്ററുകൾ ഉപയോഗിച്ചാണ് ഫയലുകൾ ആക്സസ് ചെയ്യുന്നത്, അവ ഫയലിൻ്റെ പര്യായപദമാണ്. അവ വേരിയബിളുകളല്ല, അതിനാൽ അവ മറ്റ് വേരിയബിളുകളിലേക്ക് നേരിട്ട് അസൈൻ ചെയ്യാനോ ഫംഗ്ഷനുകളിലേക്ക് കൈമാറാനോ കഴിയില്ല (ഇതിനായി, അവർ പറയുന്നതുപോലെ, മറ്റൊരു വഴിക്ക് പോകേണ്ടതുണ്ട്).

സ്റ്റാൻഡേർഡ് പെർലോവ് ഫയൽ മാനിപ്പുലേറ്ററുകളും ഉണ്ട്. അവയെ STDIN (സ്റ്റാൻഡേർഡ് ഇൻപുട്ട്), STDOUT (സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്), STDERR (സ്റ്റാൻഡേർഡ് പിശക്) എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്, STDIN വഴി ഒരു ഫോമിൽ നിന്ന് പാരാമീറ്ററുകൾ ഒരു സ്ക്രിപ്റ്റിലേക്ക് മാറ്റുന്നു (POST രീതി ഉപയോഗിക്കുന്നുവെങ്കിൽ).

നിങ്ങൾക്ക് ഒരു ഫയൽ മാനിപ്പുലേറ്ററിൻ്റെ ഒരു പകർപ്പ് സൃഷ്ടിക്കണമെങ്കിൽ (ഒരു ഫയൽ അല്ല, ഫയൽ ആക്സസ് ചെയ്യുന്ന ഒരു മാനിപ്പുലേറ്റർ മാത്രം), നിങ്ങൾക്ക് ഓപ്പൺ ഫംഗ്ഷൻ ഉപയോഗിക്കാം (അതിനെക്കുറിച്ച് ഞങ്ങൾ പിന്നീട് സംസാരിക്കും).

ഉദാഹരണം: ഓപ്പൺ(ഫിൽ,"ഫയൽ.ടിഎക്സ്ടി"); തുറക്കുക (പരാജയം,"<&FILL");

വേരിയബിളുകൾക്ക് ഫയൽ മാനിപ്പുലേറ്ററുകൾ നൽകുന്നതിനെക്കുറിച്ച്:

$ഹാൻഡിൽ=*നിറയ്ക്കുക; അല്ലെങ്കിൽ ഫംഗ്‌ഷനിലേക്ക് കൈമാറുക: some_sub(*FILL);

അവസാനമായി, ഫയലുമായി ആശയവിനിമയം നടത്താൻ മാത്രമല്ല പേളിലെ ഫയൽ മാനിപ്പുലേറ്ററുകൾ ഉപയോഗിക്കുന്നതെന്ന് ഞാൻ പറയും. അവ ചില പ്രക്രിയകൾ, സോക്കറ്റ് മുതലായവയുമായി ബന്ധപ്പെടുത്താം. എന്നാൽ ലേഖനത്തിൻ്റെ വിഷയം ഇതല്ല.

ഫയൽ കൃത്രിമത്വം

ഓപ്പൺ ഫംഗ്ഷൻ ഉപയോഗിച്ചാണ് ഫയൽ തുറക്കുന്നത്.

തുറക്കുക(FFF,"> file.txt");

നമുക്ക് അത് കണ്ടുപിടിക്കാം. പ്രവർത്തനത്തിന് മൂന്ന് പാരാമീറ്ററുകൾ ഉണ്ട്: FFF - ഫയൽ മാനിപുലേറ്ററിൻ്റെ പേര് (നിങ്ങൾ അത് സജ്ജമാക്കി), ആക്സസ് മോഡ് ">", "file.txt" - നിങ്ങൾക്ക് ആവശ്യമുള്ള ഫയലിൻ്റെ പേര്. മൂന്ന് പ്രധാന മോഡുകൾ ഉണ്ട്: ">" - റെക്കോർഡിംഗ്,"<"- чтение, ">>" - ഫയലിലേക്ക് ചേർക്കുന്നു.

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

സിസോപ്പനിൽ മൂന്നുപേരുണ്ട് ആവശ്യമായ പരാമീറ്ററുകൾഒരു ഓപ്ഷണലും.

ഉദാഹരണത്തിന്: sysopen(FH,$name, $flags, $param);

FH യഥാർത്ഥത്തിൽ ഒരു ഫയൽ മാനിപ്പുലേറ്ററാണ്, $name എന്നത് ഫയലിൻ്റെ പേരാണ് ശുദ്ധമായ രൂപം(">" മുതലായവ ഇല്ലാതെ). OR (|) വഴി താഴെ വിവരിച്ചിരിക്കുന്ന സ്ഥിരാങ്കങ്ങൾ സംയോജിപ്പിച്ച് ലഭിച്ച സംഖ്യ ഞങ്ങൾ $flags-ൽ സ്ഥാപിക്കുന്നു:

ഇത് തീർച്ചയായും അല്ല മുഴുവൻ പട്ടിക, എന്നാൽ ഏറ്റവും ആവശ്യമുള്ളതും പതിവായി ഉപയോഗിക്കുന്നതുമായ സ്ഥിരാങ്കങ്ങൾ ഇവിടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു.

ഒടുവിൽ $പരം. ഈ പരാമീറ്റർ ഫയൽ ആക്സസ് മാസ്ക് വ്യക്തമാക്കുകയും എഴുതുകയും ചെയ്യുന്നു ഒക്ടൽ സിസ്റ്റം. സാധാരണയായി ഉപയോഗിക്കുന്ന മൂല്യം 0666 ആണ് (സ്ഥിര മൂല്യം, അതായത് $param ഒഴിവാക്കിയാൽ), അല്ലെങ്കിൽ 0777. ആദ്യ മൂല്യം സാധാരണ ഫയലുകൾക്കും രണ്ടാമത്തേത് ഡയറക്ടറികൾക്കും എക്സിക്യൂട്ടബിൾ ഫയലുകൾക്കും ഉപയോഗിക്കുന്നു.

എഴുതുന്നതിനായി ഒരു ഫയൽ തുറക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം (കണ്ടെത്തിയില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും):

Sysopen(FH,"data.txt",O_WRONLY|O_TRUNC|O_CREATE);

പ്രിൻ്റ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു ഫയലിലേക്ക് എഴുതുന്നു.

അച്ചടിക്കുക(FFF "oppa! ഫയലിലേക്ക് എഴുതുക!");

ഇവിടെ FFF എന്നത് ഫയൽ മാനിപ്പുലേറ്ററിൻ്റെ പേരാണ്, കൂടാതെ ഉദ്ധരിച്ച സ്ട്രിംഗ് എന്നത് FFF-മായി ബന്ധപ്പെട്ട ഫയലിലേക്ക് എഴുതാൻ ആഗ്രഹിക്കുന്ന വാചകമാണ്.

ഫയൽ തുറക്കാനുള്ള ശ്രമത്തിന് മുമ്പ് നിലവിലില്ലെങ്കിൽ, ഓപ്പൺ ഫംഗ്ഷൻ അത് സൃഷ്ടിക്കും, ഫയൽ നിലവിലുണ്ടെങ്കിൽ അത് ശൂന്യമല്ലായിരുന്നുവെങ്കിൽ, മുകളിലുള്ള പ്രിൻ്റ് ഫംഗ്ഷനുശേഷം, മുമ്പത്തെ വിവരങ്ങളിൽ നിന്ന് ഒന്നും അതിൽ നിലനിൽക്കില്ല, ഞാൻ അവിടെ എഴുതിയ വിഡ്ഢിത്തം എഴുതപ്പെടും.

ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, മൂന്ന് സ്റ്റാൻഡേർഡ് ഫയൽ ഹാൻഡിലുകളുണ്ട്, കൂടാതെ ഫയൽ ഹാൻഡിൽ ഒഴിവാക്കിയാൽ, പ്രിൻ്റ് ഫംഗ്ഷൻ STDOUT-ലേക്ക് ഔട്ട്പുട്ട് ചെയ്യും (ഇത് ബാധകമാണ് printf ഫംഗ്ഷനുകൾഎഴുതുകയും ചെയ്യുക). ഔട്ട്പുട്ട് ദിശ മാറ്റാൻ, Perl സെലക്ട് ഫംഗ്ഷൻ നൽകുന്നു (ഇതിന് മാത്രമല്ല). ഉദാഹരണം:

തുറക്കുക(F1,"> one.txt"); പ്രിൻ്റ് "ഫയൽ തുറന്നിരിക്കുന്നു! STDOUT-ലേക്ക് എഴുതുക."; $old_point=select(F1); പ്രിൻ്റ് "ഞങ്ങൾ one.txt ഫയലിലേക്ക് എഴുതുന്നു"; തിരഞ്ഞെടുക്കുക($old_point); "വീണ്ടും STDOUT-ലേക്ക് എഴുതുക" എന്ന് അച്ചടിക്കുക; അടയ്ക്കുക (F1);

ക്ലോസ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ ഫയൽ അടയ്ക്കുന്നു.

അടയ്ക്കുക (FFF);

സ്വയം വൃത്തിയാക്കുക എന്ന തത്വം കുട്ടിക്കാലം മുതൽ എല്ലാവരിലും സന്നിവേശിപ്പിച്ചതാണ്. പ്രോഗ്രാമിംഗിൽ ഇതിനെക്കുറിച്ച് മറക്കരുത്, എന്നിരുന്നാലും ഇത് തുറന്ന പ്രക്രിയ പൂർത്തിയാക്കുമ്പോൾ ഈ ഫയൽ, ഫയൽ സ്വയമേവ അടച്ചു.

ഫയൽ ലോക്ക്

ഒന്നാമതായി, എന്തിനുവേണ്ടി? നിരവധി പ്രക്രിയകൾ ഒരേസമയം ഒരു ഫയലിലേക്ക് പ്രവേശനം നേടാനും അത് എഴുതാനും അവിടെ എന്തെങ്കിലും എഴുതാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ (ഒരു പേടിസ്വപ്നം), ഈ അത്ഭുതകരമായ ലോക്കിംഗ് സംവിധാനം ഇല്ലെങ്കിൽ എന്ത് സംഭവിക്കുമായിരുന്നുവെന്ന് സങ്കൽപ്പിക്കുക. ഇത് ഏകദേശം പറഞ്ഞാൽ, പ്രക്രിയകൾ ക്യൂ ചെയ്യാൻ അനുവദിക്കുന്നു. ഞങ്ങൾ ഇത് ചെയ്യുന്നു:

തുറക്കുക(FIL,"> file.dat"); ആട്ടിൻകൂട്ടം (FIL,2); അടയ്ക്കുക (FIL);

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

1 പങ്കിട്ട ലോക്ക് (വായിക്കുക)

2 എക്സ്ക്ലൂസീവ് ലോക്ക് (എഴുതാൻ)

4 അസിൻക്രണസ് ലോക്ക് അഭ്യർത്ഥന

8 അൺലോക്ക് ചെയ്യുന്നു

അൺലോക്ക് ചെയ്യുന്നതിനെക്കുറിച്ച്: നിലവിലെ സ്ക്രിപ്റ്റ് മൂലമുണ്ടാകുന്ന പ്രക്രിയ അവസാനിപ്പിക്കുമ്പോഴോ ലോക്ക് ചെയ്ത ഫയലുമായി "ലിങ്ക് ചെയ്ത" ഫയൽ മാനിപ്പുലേറ്റർ അടയ്ക്കുമ്പോഴോ ലോക്ക് സ്വയമേവ റിലീസ് ചെയ്യപ്പെടും. നിങ്ങൾ ലോക്ക് സ്വമേധയാ നീക്കം ചെയ്യുകയാണെങ്കിൽ, ശ്രദ്ധിക്കുക - നിങ്ങൾ അടച്ചിട്ടില്ലാത്ത ഒരു ഫയൽ ഉപയോഗിച്ച് (മുന്നറിയിപ്പ്!) ആഗ്രഹിക്കുന്നതെന്തും ചെയ്യാനുള്ള അവസരം നിങ്ങൾ മറ്റൊരു പ്രക്രിയയ്ക്ക് നൽകുന്നു! അനന്തരഫലങ്ങൾ, മിതമായ രീതിയിൽ പറഞ്ഞാൽ, അസുഖകരമായതും, ഏകദേശം പറഞ്ഞാൽ, പ്രവചനാതീതവുമാണ് (നിങ്ങൾക്ക് പ്രവചനാതീതമാണ്).

ഒരു ഫയലിലെ വരികളുമായി പ്രവർത്തിക്കുന്നു

മനുഷ്യർക്ക് ഏറ്റവും താൽപ്പര്യമുള്ള സ്ട്രിംഗ് വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്ന ഫയലുകളാണ്, അതിനാൽ നമ്മൾ ഇപ്പോൾ അവയെക്കുറിച്ച് സംസാരിക്കും.

ഒരു ഫയലിൽ നിന്നുള്ള വരികൾ വായിക്കാൻ, "ഡെലിവർ ചെയ്ത" ഫയൽ മാനിപ്പുലേറ്റർ ഉപയോഗിക്കുക<>.

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

തുറക്കുക(FIL,"data.txt"); സമയത്ത് ( ) ( # ഫയലിൻ്റെ ഓരോ വരിയിലും എന്തെങ്കിലും ചെയ്യുക )

മറ്റുവിധത്തിൽ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത്തരം ഒരു ലൂപ്പിനുള്ളിൽ "$_" എന്ന സ്റ്റാൻഡേർഡ് വേരിയബിൾ ഉപയോഗിക്കുന്നു, കൂടാതെ ലൈൻ നമ്പർ "$" എന്ന് എഴുതിയിരിക്കുന്നു. ഒരു വരിയുടെ അവസാനം ഒരു പ്രത്യേക പ്രതീകത്താൽ സൂചിപ്പിച്ചിരിക്കുന്നതിനാൽ, ഉദാഹരണത്തിന് "\n", ലൈൻ തന്നെ ലഭിക്കാൻ (അത്തരം ഒരു "ടെയിൽ" ഇല്ലാതെ) നിങ്ങൾ അത് ചോമ്പ് ഫംഗ്ഷൻ ഉപയോഗിച്ച് വെട്ടിച്ചുരുക്കേണ്ടതുണ്ട്.

തുറക്കുക(FIL,"data.txt"); സമയത്ത് ( ) (ചോമ്പ്; $_ പ്രിൻ്റ് വേരിയബിളിൽ നിന്ന് # പ്രത്യേക പ്രതീകം മുറിച്ചുമാറ്റി; STDOUT-ലേക്ക് $_ എന്ന് എഴുതുക)

@strings= ; foreach $line (@strings) ($list അച്ചടിക്കുക; )

ഒരു ഫയലിലൂടെ നീങ്ങാൻ, ടെൽ ആൻഡ് സീക്ക് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

തുറക്കുക(FIL,"data.txt"); $ സ്ഥാനം=പറയുക(FIL); "$position ഫയലിലെ നിലവിലെ സ്ഥാനം.\n" പ്രിൻ്റ് ചെയ്യുക; അന്വേഷിക്കുക(FIL,$ സ്ഥാനം+10,1); പ്രിൻ്റ് "ഇപ്പോൾ ഞങ്ങൾ നിലവിലെ സ്ഥാനത്ത് നിന്ന് ഫയലിൻ്റെ അവസാനത്തിലേക്ക് 10 ബൈറ്റുകൾ നീക്കി. \n"; $ സ്ഥാനം=പറയുക(FIL); "ഇപ്പോൾ ഫയലിലെ നിലവിലെ സ്ഥാനം $position ആണ്.\n";

ഫലമായി:

ഫയലിലെ നിലവിലെ സ്ഥാനം 0 ആണ്. ഇപ്പോൾ നമ്മൾ 10 ബൈറ്റുകൾ ഫയലിൻ്റെ അവസാനത്തിലേക്ക് നീക്കി. ഇപ്പോൾ ഫയലിലെ നിലവിലെ സ്ഥാനം 10 ആണ്.

ടെൽ ഫംഗ്‌ഷൻ ഒരു ഫയൽ മാനിപ്പുലേറ്ററിനെ ഒരു പാരാമീറ്ററായി എടുക്കുന്നു, കൂടാതെ സീക്ക് മൂന്ന് പാരാമീറ്ററുകൾ എടുക്കുന്നു. ആദ്യത്തേത് ഫയൽ മാനിപ്പുലേറ്റർ ആണ്, രണ്ടാമത്തേത് ബൈറ്റ് ഓഫ്സെറ്റ് ആണ്, മൂന്നാമത്തേത് ഓഫ്സെറ്റ് ദിശയാണ്. മൂന്ന് ഓഫ്‌സെറ്റ് ദിശകളുണ്ട്: 0 - ഫയലിൻ്റെ തുടക്കം മുതൽ, 1 - നിലവിലെ സ്ഥാനത്ത് നിന്ന്, 2 - ഫയലിൻ്റെ അവസാനം മുതൽ.

ഫയലുകളിൽ പ്രവർത്തിക്കാൻ പെർൽ ഞങ്ങൾക്ക് വാഗ്ദാനം ചെയ്യുന്നത് ഇത്രമാത്രമാണെന്ന് ഇതിനർത്ഥമില്ല. ഡയറക്‌ടറികൾക്കൊപ്പം എങ്ങനെ പ്രവർത്തിക്കാം, ജോലിയുടെ സങ്കീർണതകൾ എന്നിവയെക്കുറിച്ച് എഴുതാൻ എനിക്ക് സമയമുണ്ടാകുമെന്ന് നമുക്ക് പ്രതീക്ഷിക്കാം ബൈനറി ഫയലുകൾ, ഫയലുകളും അവയുടെ ഉള്ളടക്കങ്ങളും കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ് സമീപനം.

ഫയൽ റീഡ്/റൈറ്റ് പ്രവർത്തനങ്ങൾ നടത്താൻ രണ്ട് സെറ്റ് ഫംഗ്ഷനുകൾ പേൾ നടപ്പിലാക്കുന്നു. ഒരു സെറ്റിൻ്റെ പ്രവർത്തനങ്ങൾ ഒരു ബഫർ ഉപയോഗിക്കുന്നു - മെമ്മറിയുടെ ഒരു പ്രത്യേക മേഖല - ഒരു ഫയലിലേക്ക് വായിച്ച/എഴുതപ്പെട്ട വിവരങ്ങൾ ശേഖരിക്കുന്നതിന്, അത് പൂരിപ്പിച്ച് അല്ലെങ്കിൽ ഫയൽ അടച്ചതിന് ശേഷം, ബഫർ ഡാറ്റ ഭൗതികമായി ഡിസ്കിലേക്ക് എഴുതുകയോ പ്രോഗ്രാമിലേക്ക് അയയ്ക്കുകയോ ചെയ്യുന്നു. . പ്രിൻ്റ്, റീഡ്‌ലൈൻ എന്നിവ ഉൾപ്പെടുന്ന ഈ ഫംഗ്‌ഷനുകൾ<>, റീഡ്, ഗെറ്റ്‌സി, സീക്ക്, ടെൽ എന്നിവ സി ബഫർഡ് ഐ/ഒ ലൈബ്രറി സ്റ്റഡിയോയുടെ ദിനചര്യകളിലേക്കുള്ള ഇൻ്റർഫേസ് ഫംഗ്‌ഷനുകളാണ്. sysread, syswrite, sysseek എന്നിവ ഉൾപ്പെടുന്ന രണ്ടാമത്തെ സെറ്റ് ഫംഗ്‌ഷനുകൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൻ്റെ I/O ഫംഗ്‌ഷനുകളിലേക്ക് നേരിട്ട് ആക്‌സസ് ചെയ്യുന്നു, ഒരു ഇൻ്റർമീഡിയറ്റ് ബഫറിൽ സൂക്ഷിക്കാതെ നേരിട്ട് ഫിസിക്കൽ ഡാറ്റ റീഡ്/റൈറ്റ് പ്രവർത്തനങ്ങൾ നടത്തുന്നു. ഓപ്പൺ() അല്ലെങ്കിൽ sysopen() - എന്ന രണ്ട് ഫംഗ്ഷനുകളിൽ ഒന്ന് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ബഫർ ചെയ്തതും അൺബഫർ ചെയ്യാത്തതുമായ ഫംഗ്‌ഷനുകൾ വഴി ആക്‌സസ്സിനായി ഒരു ഫയൽ തുറക്കാൻ കഴിയും - ഒരു ഫയൽ തുറക്കുമ്പോൾ, അതിൽ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യേണ്ട ഫംഗ്‌ഷനുകൾ ഏതൊക്കെ എന്നതിന് നിയന്ത്രണമില്ല. ഒരേ ഓപ്പണിംഗ് സെഷനിൽ ഒരേ ഫയലിനായി ഈ രണ്ട് സമീപനങ്ങളും മിക്സ് ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നില്ല എന്നതാണ് ഏക ആവശ്യം, കാരണം ഇത് പ്രവചനാതീതമായ ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം.

ജാഗ്രത ഒരേ ഫയലിൽ പ്രവർത്തിക്കുമ്പോൾ, ബഫർ ചെയ്തതും അൺബഫർ ചെയ്യാത്തതുമായ I/O ഫംഗ്ഷനുകളിലേക്കുള്ള കോളുകൾ മിക്സ് ചെയ്യരുത്. സമാനമായ പ്രാക്ടീസ്പ്രവചനാതീതമായ കൂട്ടിയിടികളിലേക്ക് നയിച്ചേക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾ അൺബഫർ ചെയ്യാത്ത റീഡ്/റൈറ്റ് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കേണ്ടതുണ്ടെങ്കിൽ, ഫയലിൽ നിന്നുള്ള വിവരങ്ങൾ ഒരു ബഫർ ചെയ്‌ത ഓപ്പറേഷൻ വഴി ഇതിനകം വായിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഫയൽ അടച്ച് അത് വീണ്ടും തുറന്ന് അതിനൊപ്പം പ്രവർത്തിക്കാൻ ബഫർ ചെയ്യാത്ത ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കണം.

ബഫർ ചെയ്ത I/O

മിക്കപ്പോഴും, പ്രോഗ്രാം ടെക്സ്റ്റ് ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുന്നു. ഓപ്പറേഷൻ<>, അതിൻ്റെ ഓപ്പറാൻറ് ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ ആണ്, ഒരു ഫയലിൽ നിന്നുള്ള വിവരങ്ങൾ മുഴുവൻ "റെക്കോർഡുകളിലും" വായിക്കുന്നു, അത് സാധാരണയായി ഒരു ടെക്സ്റ്റ് ഫയലിലെ വരികളെ പ്രതിനിധീകരിക്കുന്നു. ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ പ്രയോഗിക്കുമ്പോൾ, പ്രത്യേക വേരിയബിൾ $. വർദ്ധിപ്പിച്ചുകൊണ്ട് അത് നിലവിലെ ഫയൽ റെക്കോർഡ് വായിക്കുന്നു, അത് വായിച്ച റെക്കോർഡുകളുടെ എണ്ണം ട്രാക്ക് ചെയ്യുന്നു. ഒരു ലിസ്റ്റ് സന്ദർഭത്തിൽ, ആ ഫയലിൽ ആദ്യം നിർവ്വഹിച്ചാൽ, അതേ പ്രവർത്തനം ഫയലിൻ്റെ എല്ലാ റെക്കോർഡുകളും വായിക്കും, അല്ലെങ്കിൽ ഫയലിൽ നിന്ന് മുമ്പ് മറ്റ് റീഡുകൾ ഉണ്ടായിട്ടുണ്ടെങ്കിൽ ശേഷിക്കുന്ന റെക്കോർഡുകൾ വായിക്കുകയും റീഡ് റെക്കോർഡുകളുടെ ഘടകങ്ങളുള്ള ഒരു ലിസ്റ്റ് തിരികെ നൽകുകയും ചെയ്യും. ഫയലിൻ്റെ. കൂടുതൽ കൃത്യമായി, നമുക്ക് ഓപ്പറേഷൻ എന്ന് പറയാം<>ഒരു ലിസ്റ്റ് സന്ദർഭത്തിൽ, ഫയലിൻ്റെ ശേഷിക്കുന്ന റെക്കോർഡുകൾ വായിക്കുന്നു, അതിൻ്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്നു, അത് ഓരോ റീഡ് ഓപ്പറേഷനിലും പരോക്ഷമായി മാറുന്നു, കൂടാതെ search() ഫംഗ്ഷൻ ഉപയോഗിച്ച് വ്യക്തമായി മാറ്റാൻ കഴിയും, അത് നമുക്ക് കുറച്ച് കഴിഞ്ഞ് അറിയാൻ കഴിയും. മുന്നോട്ട് നോക്കുമ്പോൾ, Perl-ലെ എല്ലാ ഫയലുകൾക്കും ഒരു ഘടനയും ഇല്ലെന്ന് നമുക്ക് പറയാം, എന്നാൽ C-യിലെന്നപോലെ, ബൈറ്റുകളുടെ ഒരു സ്ട്രീം പ്രതിനിധീകരിക്കുന്നു. റെക്കോർഡ് സെപ്പറേറ്റർ ഒരു പ്രത്യേക വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു $/, സ്ഥിരസ്ഥിതിയായി ഇത് ന്യൂലൈൻ പ്രതീകമാണ് \n. അതിനാൽ, ഉപയോക്താവ് ഒരു ഇഷ്‌ടാനുസൃത റെക്കോർഡ് സെപ്പറേറ്റർ സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ഓപ്പറേഷനിലെ ഫയൽ എൻട്രിക്ക് കീഴിൽ<>ഒരു ടെക്സ്റ്റ് ഫയലിലെ ഒരു വരി എന്നാണ് അർത്ഥമാക്കുന്നത്. മറ്റൊരു റെക്കോർഡ് സെപ്പറേറ്റർ സജ്ജീകരിക്കുന്നത് $/ വേരിയബിളിന് ഒരു പുതിയ റെക്കോർഡ് സെപ്പറേറ്റർ പ്രതീകമോ പ്രതീകങ്ങളുടെ ക്രമമോ നൽകിക്കൊണ്ടാണ് ചെയ്യുന്നത്. ലിസ്റ്റിംഗ് 6.9 ഓപ്പറേഷൻ ഉപയോഗിച്ച് ഒരു ഫയലിൽ നിന്ന് വായിക്കുന്നതിനുള്ള ചില സാങ്കേതിക വിദ്യകൾ കാണിക്കുന്നു<>. പട്ടിക 6.9. ഒരു ഫയൽ പ്രവർത്തനത്തിൽ നിന്ന് വായിക്കുന്നു<>#! perl -w ഓപ്പൺ (F1, "in.dat") അല്ലെങ്കിൽ ഡൈ "ഫയൽ തുറക്കുന്നതിൽ പിശക്: $!"; തുറക്കുക(F2, "out.dat") അല്ലെങ്കിൽ ഡൈ "ഫയൽ തുറക്കുന്നതിൽ പിശക്: $!"; $ലൈൻ1 = ; # ഫയലിൻ്റെ ആദ്യ എൻട്രി in.dat $line2 = ; in.dat ഫയലിൻ്റെ # രണ്ടാമത്തെ എൻട്രി @rest = ; # in.flat $/ = ">" ഫയലിൽ ശേഷിക്കുന്ന എൻട്രികൾ; # മറ്റൊരു റെക്കോർഡ് സെപ്പറേറ്റർ സജ്ജമാക്കുക @f2 = ; # for($i=0; $i) for out.dat ഫയലിൻ്റെ റീഡ് റെക്കോർഡുകൾ പ്രിൻ്റ് ചെയ്യുക<=$#f2; $i++) { print "Запись ".($i+1).": $f2[$i]\n"; } $/ = "\n"; # Восстановление разделителя по умолчании close (Fl) or die $!; close(F2) or die $!; open(F3, "out.dat") or die "Ошибка открытия файла: $!"; print ; # മുഴുവൻ ഫയലും അടയ്ക്കുക (F3) അല്ലെങ്കിൽ മരിക്കുക $!; ലിസ്റ്റിംഗ് 6.9-ൽ നിന്നുള്ള പ്രോഗ്രാമിനെക്കുറിച്ചുള്ള കുറച്ച് അഭിപ്രായങ്ങൾ. $line1, $line2 എന്നീ വേരിയബിളുകൾ യഥാക്രമം in.dat ഫയലിൻ്റെ ആദ്യത്തെയും രണ്ടാമത്തെയും വരികൾ വായിക്കുന്നു, കാരണം സ്ഥിരസ്ഥിതി റെക്കോർഡ് സെപ്പറേറ്റർ \n ഉപയോഗിക്കുന്നു. @rest അറേയുടെ ഘടകങ്ങൾ ഒരേ ഫയലിൻ്റെ മൂന്നാമത്തെ മുതൽ അവസാനത്തേത് വരെയുള്ള വരികൾ സംഭരിക്കുന്നു, കാരണം അസൈൻമെൻ്റ് ഓപ്പറേറ്ററിൽ ഒരു വായനാ പ്രവർത്തനം അടങ്ങിയിരിക്കുന്നു. ഒരു ലിസ്റ്റ് സന്ദർഭത്തിൽ നടപ്പിലാക്കി. out.dat ഫയലിലെ റെക്കോർഡുകൾ വായിക്കുന്നതിന് മുമ്പ്, ഒരു പുതിയ റെക്കോർഡ് സെപ്പറേറ്റർ സജ്ജീകരിച്ചിരിക്കുന്നു - > ചിഹ്നം. ഉദാഹരണത്തിന് out.dat എന്ന ഫയലിൽ Ivanov> Petrov> Sidorov> End എന്ന ഒരു വരി മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ എങ്കിൽ @f2 അറേയുടെ ഘടകങ്ങൾ അടങ്ങിയിരിക്കും. ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ: $f2 = "ഇവാനോവ്>" $f2[l] = "Petrov>" $f2 = "Sidorov>" $f2 = "അവസാനം"

ശ്രദ്ധിക്കുക out.dat ഫയൽ സൃഷ്‌ടിക്കുമ്പോൾ, അതിൻ്റെ ഒരേയൊരു വരി പുതിയ വരിയിൽ അവസാനിക്കുകയാണെങ്കിൽ (അമർത്തി കീ നൽകുക), തുടർന്ന് $f2 ൽ "End\n" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കും.

ലിസ്റ്റിംഗ് 6.9 ലെ പ്രോഗ്രാമിൻ്റെ അവസാന പ്രിൻ്റ് സ്റ്റേറ്റ്‌മെൻ്റിൽ, ഓപ്പറേഷൻ പ്രിൻ്റ്() ഫംഗ്‌ഷൻ ഒരു ലിസ്റ്റ് ഓപ്പറേഷൻ ആയതിനാൽ മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് ആവശ്യമായതിനാൽ ലിസ്റ്റ് സന്ദർഭത്തിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു. പ്രിൻ്റ് ചെയ്യുമ്പോൾ ഓരോ റെക്കോർഡിനും മുമ്പായി കുറച്ച് ടെക്‌സ്‌റ്റ് നൽകണമെങ്കിൽ, ഇതിനായി ഞങ്ങൾ ഇനിപ്പറയുന്ന പ്രസ്താവന ഉപയോഗിക്കും: "റെക്കോർഡ്:" എന്ന് പ്രിൻ്റ് ചെയ്യുക. ; അപ്പോൾ നമുക്ക് ഫയലിൻ്റെ ആദ്യ വരിയുടെ പ്രിൻ്റ്ഔട്ട് ലഭിക്കും, കാരണം ഈ സാഹചര്യത്തിൽ പ്രവർത്തനം നടക്കുന്നു ഒരു സ്കെയിലർ സന്ദർഭത്തിൽ നടപ്പിലാക്കും, പ്രവർത്തനം സൃഷ്ടിച്ചത്സ്ട്രിംഗ് കോൺകറ്റനേഷൻ (.). ആവശ്യമുള്ള ഫലം ലഭിക്കാൻ, നിങ്ങൾ ഉപയോഗിക്കണം ലൂപ്പ് സമയത്ത്: അതേസമയം( ) ( പ്രിൻ്റ് "റെക്കോർഡ്: ".$_; # ഫയൽ ഡിസ്ക്രിപ്റ്ററുമായി ബന്ധപ്പെട്ട # അടുത്ത ലൈൻ പ്രിൻ്റ് ചെയ്യുക ) ഓപ്പറേഷൻ്റെ ഫലമാണെങ്കിൽ അത് ഓർക്കുക<>ഒരു വേരിയബിളിനും നൽകിയിട്ടില്ല, അതിൻ്റെ നിർവ്വഹണത്തിൻ്റെ ഫലം പ്രത്യേക വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു S_. യഥാർത്ഥത്തിൽ ഒരു റെക്കോർഡ് റീഡ് ഓപ്പറേഷൻ<>പേളിൽ ഇത് ബിൽറ്റ്-ഇൻ റീഡ്‌ലൈൻ() ഫംഗ്‌ഷൻ വഴിയാണ് നടപ്പിലാക്കുന്നത്, അതിനെ നേരിട്ട് വിളിക്കാം. അതിൻ്റെ ഏക പരാമീറ്റർ ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്ററിലേക്കുള്ള ഒരു റഫറൻസ് ആണ്, കൂടാതെ ഡിസ്ക്രിപ്റ്റർ ഏതെങ്കിലും സാധുവായ ഡാറ്റാ തരങ്ങളിൽ (സ്കെലാർ, സ്കെയിലറുകളുടെ അറേ അല്ലെങ്കിൽ ഹാഷ് അറേ) ഉൾപ്പെടാത്തതിനാൽ, നിങ്ങൾ ഒരു പ്രത്യേക റഫറൻസ് ഉപയോഗിക്കണം. ആന്തരിക തരംപേൾ ടൈപ്പ്ഗ്ലോബ് ഡാറ്റ. ഇത് ചെയ്യുന്നതിന്, ഫയൽ ഡിസ്ക്രിപ്റ്റർ പ്രിഫിക്‌സ് ചെയ്യുക *: readline *DESCRIPTOR; ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന രണ്ട് പ്രസ്താവനകൾ പൂർണ്ണമായും തുല്യമാണ്: $line = ; $ലൈൻ = റീഡ്‌ലൈൻ *STDIN; സ്വാഭാവികമായും, $/ എന്ന പ്രത്യേക വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന റെക്കോർഡ് സെപ്പറേറ്റർ പ്രതീകങ്ങളെക്കുറിച്ച് പറഞ്ഞതെല്ലാം റീഡ്‌ലൈൻ () പ്രവർത്തനത്തിനും ബാധകമാണ്. റൈറ്റ് അല്ലെങ്കിൽ അപ്പെൻഡ് മോഡിൽ തുറന്ന ഒരു ഫയലിലേക്ക് എഴുതുന്നത് പ്രിൻ്റ്() ഫംഗ്‌ഷൻ മുഖേനയാണ് ചെയ്യുന്നത്. ആദ്യത്തെ പാരാമീറ്റർ ഒരു ഫയൽ ഡിസ്‌ക്രിപ്‌റ്ററാണ്: പ്രിൻ്റ് OUTPUT_LIST DESCRIPTOR; ഈ പ്രവർത്തനം ലിസ്റ്റ് ഘടകങ്ങളുടെ ഉള്ളടക്കങ്ങൾ ഫംഗ്‌ഷൻ കോളിൽ നിർവചിച്ചിരിക്കുന്ന ക്രമത്തിൽ എഴുതുന്നു, കൂടാതെ ലിസ്റ്റിൻ്റെ അവസാനം ഒരു റെക്കോർഡ് സെപ്പറേറ്ററോ ന്യൂലൈനോ ചേർക്കുന്നില്ല. ഔട്ട്‌പുട്ട് ലിസ്റ്റിൻ്റെ അവസാനത്തിൽ ഒരു റെക്കോർഡ് സെപ്പറേറ്ററോ ന്യൂലൈൻ പ്രതീകമോ വ്യക്തമായി ചേർത്തോ അല്ലെങ്കിൽ $\ എന്ന പ്രത്യേക വേരിയബിൾ നൽകുന്ന അവസരം പ്രയോജനപ്പെടുത്തിക്കൊണ്ടോ പ്രോഗ്രാമർ തന്നെ ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്. പ്രിൻ്റ് ഫംഗ്‌ഷൻ ഈ പ്രത്യേക വേരിയബിളിൻ്റെ ഉള്ളടക്കങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു, അതിൽ സ്ഥിരസ്ഥിതിയായി ഒരു ശൂന്യമായ സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു, അതിൻ്റെ ഔട്ട്‌പുട്ട് ലിസ്റ്റിൻ്റെ അവസാനം: # റെക്കോർഡ് സെപ്പറേറ്റർ പ്രിൻ്റ് F1 @recl1, "\n" വ്യക്തമായി സജ്ജമാക്കുക; $\ = "\n"; # റെക്കോർഡ് സെപ്പറേറ്റർ സജ്ജീകരിക്കുന്നു # ഇപ്പോൾ റെക്കോർഡ് സെപ്പറേറ്റർ പരോക്ഷമായി ഔട്ട്പുട്ട് ചെയ്യും # ഓരോ തുടർന്നുള്ള ഫംഗ്‌ഷൻ പ്രിൻ്റ് പ്രിൻ്റ് F1 @reсl2;

മുന്നറിയിപ്പ് ഫയൽ ഡിസ്ക്രിപ്റ്ററിനും ഔട്ട്പുട്ട് ലിസ്റ്റിൻ്റെ ആദ്യ ഘടകത്തിനും ഇടയിൽ ഒരു കോമ ഉണ്ടാകരുത്. ഇങ്ങനെ സംഭവിക്കുകയാണെങ്കിൽ, perl വ്യാഖ്യാതാവ് ഒരു പിശക് വരുത്തും: ഫയൽഹാൻഡിലിനുശേഷം കോമ അനുവദനീയമല്ല.

ഒരു ഫയലിലേക്ക് വിവരങ്ങൾ എഴുതുമ്പോൾ, പ്രിൻ്റ്() ഫംഗ്ഷന് മറ്റൊരു ഉപയോഗപ്രദമായ സവിശേഷത പ്രയോജനപ്പെടുത്താം. പ്രത്യേക വേരിയബിളിൻ്റെ മൂല്യം $ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് ഔട്ട്പുട്ട് ലിസ്റ്റിൻ്റെ ഘടകങ്ങൾക്കിടയിൽ ചേർക്കുന്നു. ഉദാഹരണത്തിന്, ലിസ്റ്റ് ഘടകങ്ങളുടെ മൂല്യങ്ങൾ പ്രതീകങ്ങളുടെ തുടർച്ചയായ സ്ട്രീം ആയി പ്രദർശിപ്പിക്കാതെ ഒരു സ്‌പെയ്‌സ് കൊണ്ട് വേർതിരിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഈ പ്രത്യേക വേരിയബിളിൻ്റെ മൂല്യം ഒരു സ്‌പെയ്‌സിന് തുല്യമായി സജ്ജീകരിക്കണം: $var1 = "11111"; Svar2 = "22222"; $var1, $var2, "\n" എന്നിവ അച്ചടിക്കുക; $, = ""; $var1, $var2, "\n" എന്നിവ അച്ചടിക്കുക; ആദ്യത്തെ പ്രിൻ്റ് സ്റ്റേറ്റ്മെൻ്റ് പ്രിൻ്റ് ചെയ്യും: 1111122222 രണ്ടാമത്തെ പ്രിൻ്റ് സ്റ്റേറ്റ്മെൻ്റ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ നമുക്ക് സ്ട്രിംഗ് ലഭിക്കും: 11111 22222

ശ്രദ്ധിക്കുക $\, $ എന്നീ പ്രത്യേക വേരിയബിളുകളുടെ മൂല്യങ്ങൾ സജ്ജീകരിക്കുമ്പോൾ, പ്രിൻ്റ്() ഫംഗ്ഷനിലേക്കുള്ള എല്ലാ തുടർന്നുള്ള കോളുകൾക്കും അവയുടെ പ്രഭാവം ബാധകമാണ്.

പ്രിൻ്റ് ഫംഗ്‌ഷൻ ഒരു ഫയൽ ഡിസ്‌ക്രിപ്‌റ്റർ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഡിഫോൾട്ട് ഔട്ട്‌പുട്ട് STDOUT ഡിസ്‌ക്രിപ്‌റ്റർ ഉള്ള സ്റ്റാൻഡേർഡ് ഔട്ട്‌പുട്ട് ഫയലിലേക്കാണ്, കൂടാതെ ഔട്ട്‌പുട്ട് ലിസ്റ്റ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, പ്രത്യേക വേരിയബിളിൻ്റെ ഉള്ളടക്കം $_ പ്രിൻ്റ് ചെയ്യപ്പെടും. പ്രിൻ്റ്() ഫംഗ്‌ഷൻ ഹാൻഡിൻ്റെ സ്ഥിരസ്ഥിതി ക്രമീകരണം സ്റ്റാൻഡേർഡ് സെലക്ട്() ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് മാറ്റാവുന്നതാണ്. പാരാമീറ്ററുകൾ ഇല്ലാതെ വിളിക്കുന്നു, ഇത് പ്രിൻ്റ്(), റൈറ്റ്() ഫംഗ്‌ഷനുകൾക്കായി നിലവിലെ ഡിഫോൾട്ട് ഔട്ട്‌പുട്ട് ഫയൽ ഹാൻഡിൽ നൽകുന്നു. ഇത് ഒരൊറ്റ പാരാമീറ്റർ പാസ്സാക്കിയാൽ, ആ പരാമീറ്റർ ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ ആയിരിക്കണം. ഈ സാഹചര്യത്തിൽ, അത് നിലവിലെ ഡിഫോൾട്ട് ഹാൻഡിൽ തിരികെ നൽകുകയും അതിന് കൈമാറിയ പാരാമീറ്റർ വ്യക്തമാക്കിയ ഹാൻഡിലിലേക്ക് മാറ്റുകയും ചെയ്യുന്നു. ഉപയോഗ ഉദാഹരണം പ്രവർത്തനങ്ങൾ തിരഞ്ഞെടുക്കുക() താഴെ കൊടുത്തിരിക്കുന്നു. # നിലവിലെ ഡിഫോൾട്ട് ഹാൻഡിൽ സംരക്ഷിച്ച് # F1 പുതിയ ഡിഫോൾട്ട് ഹാൻഡിൽ $oldfilehandle = തിരഞ്ഞെടുക്കുക (Fl); # Fl ഡിസ്ക്രിപ്റ്റർ പ്രിൻ്റ് $ ലൈനുമായി ബന്ധപ്പെട്ട ഫയലിലേക്കുള്ള ഔട്ട്പുട്ട്; # പഴയ ഡിഫോൾട്ട് ഹാൻഡിൽ സെലക്ട് ($oldfilehandle) പുനഃസ്ഥാപിക്കുക; പഴയ ഡിസ്ക്രിപ്റ്റർ പ്രിൻ്റ് $ലൈനുമായി ബന്ധപ്പെട്ട ഫയലിലേക്കുള്ള ഔട്ട്പുട്ട്; സൂചിപ്പിച്ചതുപോലെ, Perl-ലെ ഫയലുകൾ ഘടനയില്ലാത്ത ബൈറ്റ് സ്ട്രീമുകളായി വ്യാഖ്യാനിക്കപ്പെടുന്നു. അത് ഒരു ഓപ്പറേഷൻ്റെ സഹായത്തോടെ<> കൂടാതെ പ്രിൻ്റ്() ഫംഗ്‌ഷൻ യഥാക്രമം ബൈറ്റുകളുടെ ഒരു മുഴുവൻ ശ്രേണിയും ഞങ്ങൾ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്നു, അതിനെ ഞങ്ങൾ "റെക്കോർഡ്" എന്ന് വിളിക്കുന്നു, ഒരു പ്രത്യേക ഫയൽ ഘടനയുമായി യാതൊരു ബന്ധവുമില്ല. ഒരാൾ വായിക്കുകയും രണ്ടാമത്തേത് ബൈറ്റുകളുടെ ക്രമങ്ങൾ എഴുതുകയും ചെയ്യുന്ന വിധത്തിലാണ് ഈ പ്രവർത്തനങ്ങൾ ക്രമീകരിച്ചിരിക്കുന്നത് എന്ന് മാത്രം. വാസ്തവത്തിൽ, നമുക്ക് ഒരു സമയം ഒരു ബൈറ്റ് ഒരു ഫയലിലേക്ക് വിവരങ്ങൾ വായിക്കാനും എഴുതാനും കഴിയും. ഓരോ ഓപ്പൺ ഫയലിനും, ഒരു സിസ്റ്റം വേരിയബിൾ സൃഷ്ടിക്കപ്പെടുന്നു, അത് അതിൻ്റെ നിലവിലെ സ്ഥാനം ട്രാക്കുചെയ്യുന്നു, അതായത്, റീഡ് ഫംഗ്ഷനുകൾ വായിക്കുകയും റൈറ്റ് ഫംഗ്ഷനുകൾ വിവരങ്ങൾ എഴുതുകയും ചെയ്യുന്ന ഫയലിലെ സ്ഥലം. അതിനാൽ, നിലവിലെ ഫയൽ സ്ഥാനത്ത് നിന്ന് റീഡ് / റൈറ്റ് പ്രവർത്തനങ്ങൾ നടത്തുന്നുവെന്ന് നമുക്ക് പറയാം. ഏതെങ്കിലും റീഡ്/റൈറ്റ് ഓപ്പറേഷൻ നടത്തുമ്പോൾ, നിലവിലെ ഫയൽ പൊസിഷൻ പോയിൻ്റർ വായിച്ചതോ എഴുതിയതോ ആയ ബൈറ്റുകളുടെ എണ്ണം കൊണ്ട് നീക്കുന്നു. ഉദാഹരണത്തിന്, ഫയലിൻ്റെ തുടക്കം മുതൽ 80-ബൈറ്റ് റെക്കോർഡ് വായിച്ചിട്ടുണ്ടെങ്കിൽ, അടുത്ത റീഡ് അല്ലെങ്കിൽ റൈറ്റ് പ്രവർത്തനം ഫയലിൻ്റെ 81 ബൈറ്റുകളുടെ സ്ഥാനത്ത് ആരംഭിക്കും. ഒരു ഫയലിലെ നിലവിലെ സ്ഥാനം നിർണ്ണയിക്കാൻ, പറയുക() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു, അതിൻ്റെ ഏക പരാമീറ്റർ ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ ആകാം. നൽകിയിരിക്കുന്ന ഫയൽ ഡിസ്ക്രിപ്റ്ററുമായി ബന്ധപ്പെട്ട ഫയലിലെ നിലവിലെ സ്ഥാനം ഇത് നൽകുന്നു. ഒരു പരാമീറ്ററില്ലാത്ത അതേ ഫംഗ്ഷൻ പ്രോഗ്രാമിൽ അവസാനമായി റീഡ് ഓപ്പറേഷൻ നടത്തിയ ഫയലിലെ നിലവിലെ സ്ഥാനം നൽകുന്നു. നിർവഹിച്ച റീഡ്/റൈറ്റ് ഓപ്പറേഷനുകൾക്ക് അനുസൃതമായി ഫയലിലെ നിലവിലെ സ്ഥാനം സ്വയമേവ മാറ്റപ്പെടും, എന്നാൽ ഫയൽ ഡിസ്ക്രിപ്റ്റർ, ഓഫ്സെറ്റ്, ഒറിജിൻ എന്നീ പാരാമീറ്ററുകളായി കൈമാറുന്ന സീക്ക്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇത് വ്യക്തമായി മാറ്റാവുന്നതാണ്. ഡിസ്ക്രിപ്റ്ററുമായി ബന്ധപ്പെട്ട ഫയലിനായി, റഫറൻസ് പോയിൻ്റുമായി ബന്ധപ്പെട്ട OFFSET പാരാമീറ്റർ വ്യക്തമാക്കിയ ബൈറ്റുകളുടെ എണ്ണം ഉപയോഗിച്ച് ഒരു പുതിയ നിലവിലെ സ്ഥാനം സജ്ജീകരിച്ചിരിക്കുന്നു: DESCRIPTOR, OFFSET, REFERENCE POINT എന്നിവ തേടുക; REFERENCE_POINT പാരാമീറ്ററിന് മൂന്ന് മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കാം: 0 - ഫയലിൻ്റെ ആരംഭം, 1 - നിലവിലെ സ്ഥാനം, 2 - ഫയലിൻ്റെ അവസാനം. ഓഫ്സെറ്റ് പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് ആകാം. ഫയലിൻ്റെ അവസാനത്തെ അപേക്ഷിച്ച് ഇത് നെഗറ്റീവ് ആണ്, ഫയലിൻ്റെ തുടക്കവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ പോസിറ്റീവ് ആണ്, കൂടാതെ നിലവിലെ സ്ഥാനവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് ആകാം. Perl's IO::Seekable പാക്കേജിൽ നിർവചിച്ചിരിക്കുന്ന SEEK_SET, SEEK_CUR, SEEK_END എന്ന പേരിലുള്ള സ്ഥിരാങ്കങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് റഫറൻസ് പോയിൻ്റുകൾ സജ്ജീകരിക്കാനും കഴിയും, ഇത് പ്രോഗ്രാമിനെ കൂടുതൽ വായിക്കാനാകുന്നതാക്കുന്നു. ഈ സ്ഥിരാങ്കങ്ങൾ, ഞങ്ങൾ പട്ടികപ്പെടുത്തിയ ക്രമത്തിൽ, ഫയലിൻ്റെ ആരംഭം, നിലവിലെ സ്ഥാനം, ഫയലിൻ്റെ അവസാനം എന്നിവയുമായി പൊരുത്തപ്പെടുന്നു. നിർദ്ദിഷ്ട പേരുള്ള സ്ഥിരാങ്കങ്ങൾ ഉപയോഗിക്കുന്നതിന്, തീർച്ചയായും, ഉപയോഗ കീവേഡ് ഉപയോഗിച്ച് പ്രോഗ്രാമിൽ ഈ മൊഡ്യൂൾ ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന പ്രസ്താവനകൾ ഫയലുകളിലെ നിലവിലെ സ്ഥാനങ്ങൾ അതേപടി സജ്ജമാക്കുന്നു: IO ഉപയോഗിക്കുക::Seekable: FILE1, 5, 0 തിരയുക; FILE2, 5, SEEK_SET തിരയുക; ഭാഷയിലല്ല പ്രത്യേക പ്രവർത്തനങ്ങൾഫയലിൻ്റെ തുടക്കത്തിലോ അവസാനത്തിലോ പോകുക. നിങ്ങൾക്ക് ഒരു ഫയൽ തുടക്കത്തിലോ അവസാനത്തിലോ സ്ഥാപിക്കണമെങ്കിൽ, സീക്() ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ അനുബന്ധ റഫറൻസ് പോയിൻ്റുകളുമായി ബന്ധപ്പെട്ട് പൂജ്യം ഓഫ്‌സെറ്റ് ഉപയോഗിക്കണം: FILE1, 0, 0 തിരയുക; # ഫയലിൻ്റെ തുടക്കത്തിലേക്ക് പോകുക FILE1, 0, 2 തിരയുക; # ഫയൽ റെക്കോർഡുകൾ വായിക്കുന്നതിനുള്ള ഇതിനകം പരിചിതമായ പ്രവർത്തനങ്ങൾക്ക് പുറമേ ഫയലിൻ്റെ അവസാനത്തിലേക്ക് നീങ്ങുക<> റെഡ്‌ലൈൻ(), ഫയലുകളുടെ ഉള്ളടക്കങ്ങൾ വായിക്കുന്നതിന് പേൾ രണ്ട് ഫംഗ്‌ഷനുകൾ കൂടി നൽകുന്നു - getc(), read(). ആദ്യത്തേത് ഒരു ഫയലിൽ നിന്ന് ഒരൊറ്റ ബൈറ്റ് വായിക്കുന്നു, രണ്ടാമത്തേത് ഒരു നിശ്ചിത ദൈർഘ്യത്തിൻ്റെ റെക്കോർഡുകൾ വായിക്കുന്നു, അതായത് ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള ബൈറ്റുകളുടെ ക്രമം. getc() ഫംഗ്‌ഷൻ നിലവിലെ ഫയൽ സ്ഥാനത്തുള്ള പ്രതീകം വായിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു, അതിൻ്റെ ഹാൻഡിൽ ഒരു പാരാമീറ്ററായി കൈമാറുന്നു, അല്ലെങ്കിൽ ഫയലിൻ്റെ അവസാനത്തിൽ എത്തിയാലോ പിശക് സംഭവിക്കുമ്പോഴോ നിർവചിക്കാത്ത മൂല്യം. ഒരു പാരാമീറ്റർ ഇല്ലാതെ ഫംഗ്ഷൻ വിളിക്കുകയാണെങ്കിൽ, അത് സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് ഫയലായ STDIN-ൽ നിന്ന് ഒരു പ്രതീകം വായിക്കുന്നു. getc; # STDIN getc F1-ൽ നിന്നുള്ള ഒരു പ്രതീകം വായിക്കുക; # ഹാൻഡിൽ F1 ഉപയോഗിച്ച് നിലവിലെ ഫയൽ സ്ഥാനത്ത് ഒരു പ്രതീകം വായിക്കുക റീഡ്() ഫംഗ്‌ഷൻ അതിൻ്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്ന ഒരു നിശ്ചിത എണ്ണം ബൈറ്റുകൾ വായിക്കുന്നു. മൂന്നോ നാലോ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഇതിനെ വിളിക്കാം, അതിൻ്റെ കോൾ ഈ രൂപത്തിലാണ്: DESCRIPTOR, VARIABLE, LENGTH [,OFFset] വായിക്കുക; ഈ ഫംഗ്‌ഷൻ, LENGTH പാരാമീറ്ററിൻ്റെ പൂർണ്ണ മൂല്യം വ്യക്തമാക്കിയ ബൈറ്റുകളുടെ എണ്ണം ഫയലിൽ നിന്ന് VARIABLE പാരാമീറ്റർ വ്യക്തമാക്കിയ സ്കെയിലർ വേരിയബിളിലേക്ക് ആദ്യത്തെ DESCRIPTOR പാരാമീറ്റർ വ്യക്തമാക്കിയ ഹാൻഡിൽ ഉപയോഗിച്ച് റീഡ് ചെയ്യുന്നു. റിട്ടേൺ മൂല്യം എന്നത് യഥാർത്ഥത്തിൽ വായിച്ച ബൈറ്റുകളുടെ എണ്ണമാണ്, ഫയലിൻ്റെ എൻഡ്-ഓഫ്-ഫയൽ സ്ഥാനത്ത് വായിക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ 0, മറ്റ് പിശകുകൾ സംഭവിച്ചാൽ അത് നിർവചിക്കില്ല. വേരിയബിൾ വേരിയബിളിൻ്റെ ഉള്ളടക്കത്തിൻ്റെ ഏത് ബൈറ്റിന് ശേഷം ഫയലിൽ നിന്ന് വായിച്ച റെക്കോർഡ് സംരക്ഷിക്കപ്പെടുമെന്ന് ഓപ്ഷണൽ ഓഫ്സെറ്റ് പാരാമീറ്റർ നിർണ്ണയിക്കുന്നു. ഇതിന് ഒരു നെഗറ്റീവ് ഓഫ്‌സെറ്റ് മൂല്യവും ഉണ്ടായിരിക്കാം -n (n ഒരു പൂർണ്ണസംഖ്യയാണ്). അതായത് VARIABLE എന്ന വേരിയബിളിൻ്റെ ഉള്ളടക്കത്തിൻ്റെ അവസാന n ബൈറ്റുകൾ നിരസിക്കുകയും ഫയലിൽ നിന്ന് വായിച്ച റെക്കോർഡ് ശേഷിക്കുന്ന വരിയിലേക്ക് ചേർക്കുകയും ചെയ്യുന്നു എന്നാണ്. ലിസ്റ്റിംഗ് 6.10 മൂന്ന് വരി ഡാറ്റ അടങ്ങുന്ന in.dat ഫയലിൽ നിന്ന് ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള റീഡിംഗ് റെക്കോർഡുകൾ കാണിക്കുന്നു: ******** * PERL * ******* ലിസ്റ്റിംഗ് 6.10. ഒരു നിർദ്ദിഷ്‌ട ദൈർഘ്യത്തിൻ്റെ റെക്കോർഡുകൾ വായിക്കുക #! perl -w open(F1, "in.dat") അല്ലെങ്കിൽ ഡൈ "ഫയൽ തുറക്കുന്നതിൽ പിശക്: $!"; $str = "1234567890"; F1, $str, 9 വായിക്കുക; # ഓഫ്‌സെറ്റ് പ്രിൻ്റ് $str,"\n" ഇല്ലാതെ # വേരിയബിളായ $str-ലേക്ക് ഒമ്പത് ബൈറ്റുകൾ വായിക്കുക; # $str = "********\n" F1, $str, 8, ദൈർഘ്യം ($str) വായിക്കുക; $str,"\n"; # $str - "*******\n* PERL *" ലിസ്റ്റിംഗ് 6.10 ലെ പ്രോഗ്രാം ഒരു സ്കെലാർ വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ (ബൈറ്റുകൾ) എണ്ണം നിർണ്ണയിക്കാൻ നീളം() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. ആദ്യത്തെ റീഡ് ഓപ്പറേഷനുശേഷം, $str വേരിയബിളിൻ്റെ ഉള്ളടക്കങ്ങൾ നശിപ്പിക്കപ്പെട്ടു, കാരണം ഈ റീഡ്() ഫംഗ്‌ഷൻ മിശ്രണം ചെയ്യാതെ വിളിച്ചു. രണ്ടാമത്തെ വായനയിൽ, $str വേരിയബിളിൽ സംഭരിച്ച ഡാറ്റ പൂർണ്ണമായും സംരക്ഷിക്കപ്പെട്ടു. ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള റെക്കോർഡുകൾ റീഡ്() വായിക്കുമ്പോൾ in.dat ഫയലിൻ്റെ ആദ്യ വരിയിൽ അടങ്ങിയിരിക്കുന്ന പുതിയ വരിയും കണക്കിലെടുക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. റീഡ് () ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു "മൾട്ടി-ലൈൻ" ഫയലിൽ നിന്നുള്ള വിവരങ്ങൾ വായിക്കുമ്പോൾ ഈ സാഹചര്യത്തെക്കുറിച്ച് നിങ്ങൾ മറക്കരുത്.

ബഫർ ചെയ്യാത്ത I/O

sysread() ഫയലിൽ നിന്ന് വായിക്കുക, ഒരു ഫയലിലേക്ക് എഴുതുക, sysswrite() എന്ന ഫയലിലേക്ക് പോയിൻ്റർ സജ്ജീകരിക്കുക, sysseek() എന്ന നിലവിലെ ഫയൽ സ്ഥാനത്തേക്ക് പോയിൻ്റർ സജ്ജീകരിക്കുക എന്നീ പ്രവർത്തനങ്ങൾ ഞങ്ങൾ പരിഗണിച്ച റീഡ്(), പ്രിൻ്റ്(), സീക്ക്() ഫംഗ്‌ഷനുകളുടെ അനലോഗ് ആണ്. , രണ്ടാമത്തേതിൽ നിന്ന് വ്യത്യസ്തമായി, സ്റ്റാൻഡേർഡ് C I/O ലൈബ്രറിയുടെ ഫംഗ്‌ഷനുകളേക്കാൾ, അനുബന്ധ സിസ്റ്റം ഓപ്പറേഷൻ ഫംഗ്‌ഷനുകളിലേക്ക് അവ നേരിട്ട് ആക്‌സസ് ചെയ്യുന്നു, അതുവഴി ഫയലിൽ റീഡ് ആൻഡ് റൈറ്റ് പ്രവർത്തനങ്ങൾ നടത്താൻ ഈ ഫംഗ്‌ഷനുകൾ സൃഷ്‌ടിച്ച ബഫറിനെ മറികടക്കുന്നു. ബഫർ ചെയ്‌ത ടെൽ() ഫംഗ്‌ഷന് തുല്യമായത് ഒന്നുമില്ല എന്നത് ശ്രദ്ധിക്കുക; അതിൻ്റെ പ്രവർത്തനം sysseek() ഫംഗ്‌ഷനാണ് നടപ്പിലാക്കുന്നത്. അൺബഫർ ചെയ്യാത്ത റീഡ് ആൻഡ് റൈറ്റ് ഫംഗ്ഷനുകളെ വിളിക്കുമ്പോൾ, അവ റീഡ് ഫംഗ്‌ഷൻ്റെ പാരാമീറ്ററുകളുമായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്ന അതേ പാരാമീറ്ററുകൾ കൈമാറുന്നു: sysread DESCRIPTOR, VARIABLE, LENGTH [, OFFSET]; സിസ്‌റൈറ്റ് ഡിസ്‌ക്രിപ്‌റ്റർ, വേരിയബിൾ, നീളം [, ഓഫ്‌സെറ്റ്]; ഈ ഫംഗ്‌ഷനുകളുടെ റിട്ടേൺ മൂല്യം യഥാക്രമം ഫയലിൽ വായിച്ചതോ എഴുതിയതോ ആയ ബൈറ്റുകളുടെ യഥാർത്ഥ സംഖ്യയാണ്, ഫയലിൻ്റെ അവസാനം എത്തിയാൽ 0, അല്ലെങ്കിൽ ഒരു പിശക് സംഭവിച്ചാൽ undef. അതനുസരിച്ച്, sysseek() ഫംഗ്‌ഷൻ്റെ പാരാമീറ്ററുകളുടെ സെറ്റ് സീക്ക്() ഫംഗ്‌ഷനിലേക്ക് കൈമാറിയ പരാമീറ്ററുകളുമായി പൂർണ്ണമായും പൊരുത്തപ്പെടുന്നു: sysseek DESCRIPTOR, OFFSET, REFERENCE_POINT; സീക്ക്() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് പറഞ്ഞതെല്ലാം അതിൻ്റെ ബഫർ ചെയ്യാത്ത കൗണ്ടർപാർട്ടിന് പൂർണ്ണമായും ബാധകമാണ്. sysseek() ഫംഗ്‌ഷനെ ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കുന്നതിലൂടെയാണ് ബഫർ ചെയ്‌ത ടെൽ() പ്രവർത്തനം നടപ്പിലാക്കുന്നത്: $position = sysseek Fl, 0, 1; # നിലവിലെ ഫയൽ പോയിൻ്റർ സ്ഥാനം ഒരു ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് അൺബഫർ ചെയ്യാത്ത I/O ഫംഗ്‌ഷനുകളുടെ ഉപയോഗം പ്രോഗ്രാം കാണിക്കുന്നു. #! perl -w Fcntl ഉപയോഗിക്കുന്നു; # റീഡ്/റൈറ്റ് മോഡിൽ ഒരു ഫയൽ തുറക്കൽ sysopen F1, "in.dat", O_RDWR; # 14 ബൈറ്റുകളുടെ ഒരു ബ്ലോക്ക് വായിക്കുക $read = sysread F1, $string, 14; $read != 14 എങ്കിൽ "14\n എന്നതിനുപകരം റീഡ് ബൈറ്റുകൾ റീഡ് ചെയ്യുക" എന്ന് മുന്നറിയിപ്പ് നൽകുക; # നിലവിലെ സ്ഥാനം സജ്ജമാക്കുക (15 ബൈറ്റുകൾ കൊണ്ട്) $ സ്ഥാനം = sysseek Fl, 0, 1; "പൊസിഷനിംഗ് പിശക്: $!\n" $position നിർവചിച്ചിട്ടില്ലെങ്കിൽ; # നിലവിലെ സ്ഥാനത്ത് ഒരു സ്ട്രിംഗ് എഴുതുക $string = "പുതിയ മൂല്യം"; $written = syswrite F1, $string, length ($string); "എഴുത്ത് പിശക്: $!\n" എന്നെഴുതിയാൽ != ദൈർഘ്യം($string); # ഒരു ഫയൽ ക്ലോസ് ചെയ്യുക F1 ക്ലോസ് ചെയ്യുക അല്ലെങ്കിൽ $ ഡൈ ചെയ്യുക! ബഫർ ചെയ്യാത്ത I/O ഫംഗ്‌ഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, ഒരു റീഡ്, റൈറ്റ്, അല്ലെങ്കിൽ പൊസിഷൻ ഓപ്പറേഷൻ പൂർത്തിയാകുന്നുണ്ടോയെന്ന് നിങ്ങൾ എപ്പോഴും പരിശോധിക്കണം. സ്റ്റാൻഡേർഡ് സിസ്റ്റംബഫർ ചെയ്ത I/O നടപ്പിലാക്കിയ I/O, നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങളുടെ പൂർത്തീകരണം സ്വയം പരിശോധിക്കുന്നു, എഴുത്തിൻ്റെ മധ്യത്തിൽ എന്തെങ്കിലും കാരണത്താൽ പ്രക്രിയ തടസ്സപ്പെട്ടാൽ അതിന് ഉത്തരവാദിയായിരിക്കും. ബഫർ ചെയ്യാത്ത I/O ഉപയോഗിച്ച്, ഇത് പ്രോഗ്രാമർ ശ്രദ്ധിക്കേണ്ടതാണ്.