perltie - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

perltie - ഒരു ഒബ്ജക്റ്റ് ക്ലാസ് ഒരു ലളിതമായ വേരിയബിളിൽ എങ്ങനെ മറയ്ക്കാം

സിനോപ്സിസ്

ടൈ വേരിയബിൾ, ക്ലാസ് നാമം, ലിസ്റ്റ്

$object = tied VARIABLE

വേരിയബിൾ അഴിക്കുക

വിവരണം

Perl-ന്റെ 5.0 പുറത്തിറക്കുന്നതിന് മുമ്പ്, ഒരു പ്രോഗ്രാമർക്ക് ഉപയോഗിക്കാമായിരുന്നു dbmopen() ഒരു ഓൺ-ഡിസ്ക് ബന്ധിപ്പിക്കുന്നതിന്
സ്റ്റാൻഡേർഡ് യുണിക്സിലെ ഡാറ്റാബേസ് dbm(3x) അവരുടെ പ്രോഗ്രാമിലെ %HASH-ലേക്ക് മാന്ത്രികമായി ഫോർമാറ്റ് ചെയ്യുക.
എന്നിരുന്നാലും, അവരുടെ പേൾ ഒന്നുകിൽ ഒരു പ്രത്യേക ഡിബിഎം ലൈബ്രറി ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്, പക്ഷേ അല്ല
രണ്ടും, നിങ്ങൾക്ക് ഈ സംവിധാനം മറ്റ് പാക്കേജുകളിലേക്കോ വേരിയബിളുകളിലേക്കോ വിപുലീകരിക്കാൻ കഴിയില്ല.

ഇപ്പോൾ നിങ്ങൾക്ക് കഴിയും.

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

ൽ ടൈ() വിളിക്കുക, "VARIABLE" എന്നത് മാന്ത്രികമാക്കേണ്ട വേരിയബിളിന്റെ പേരാണ്. "CLASSNAME" ആണ്
ശരിയായ തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകൾ നടപ്പിലാക്കുന്ന ഒരു ക്ലാസിന്റെ പേര്. ഏതെങ്കിലും അധിക വാദങ്ങൾ
"LIST" ആ ക്ലാസ്സിന് അനുയോജ്യമായ കൺസ്ട്രക്റ്റർ രീതിയിലേക്ക് കൈമാറുന്നു - അർത്ഥം
ടൈസ്‌കലാർ(), TIARRAY(), തിഹാഷ്(), അഥവാ ടൈഹാൻഡിൽ(). (സാധാരണയായി ഇവ അത്തരം വാദങ്ങളാണ്
ലേക്ക് കൈമാറാം dbminit() C യുടെ പ്രവർത്തനം.) "പുതിയത്" നൽകിയ വസ്തു
രീതിയും തിരികെ നൽകുന്നു ടൈ() ഫംഗ്‌ഷൻ, അത് നിങ്ങൾക്ക് വേണമെങ്കിൽ ഉപയോഗപ്രദമാകും
"CLASSNAME" എന്നതിലെ മറ്റ് രീതികൾ ആക്സസ് ചെയ്യുക. (നിങ്ങൾ യഥാർത്ഥത്തിൽ ഒരു റഫറൻസ് തിരികെ നൽകേണ്ടതില്ല
ശരിയായ "തരം" (ഉദാ, HASH അല്ലെങ്കിൽ "CLASSNAME") ശരിയായ രീതിയിൽ അനുഗൃഹീതമായ ഒരു വസ്തുവാണ്.) നിങ്ങൾ
ഉപയോഗിച്ച് അടിസ്ഥാന ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ് വീണ്ടെടുക്കാനും കഴിയും കെട്ടി () പ്രവർത്തനം.

വ്യത്യസ്തമായി dbmopen(), ടൈ() ഫംഗ്‌ഷൻ നിങ്ങൾക്കായി ഒരു മൊഡ്യൂൾ "ഉപയോഗിക്കുക" അല്ലെങ്കിൽ "ആവശ്യപ്പെടില്ല"
അത് സ്വയം വ്യക്തമായി ചെയ്യേണ്ടതുണ്ട്.

കെട്ടുന്നു സ്കെയിലറുകൾ
ഒരു ടൈഡ് സ്കെയിലർ നടപ്പിലാക്കുന്ന ഒരു ക്ലാസ് ഇനിപ്പറയുന്ന രീതികൾ നിർവചിക്കേണ്ടതാണ്: TIESCALAR, FETCH,
സംഭരിക്കുക, ഒരുപക്ഷേ UNTIE കൂടാതെ/അല്ലെങ്കിൽ നശിപ്പിക്കുക.

നമുക്ക് ഓരോന്നും നോക്കാം, ഉദാഹരണമായി സ്കെയിലറുകൾക്കായുള്ള ഒരു ടൈ ക്ലാസ് ഉപയോഗിച്ച്
ഉപയോക്താവ് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ:

ടൈ $his_speed, 'Nice', getppid();
tie $my_speed, 'Nice', $$;

ഇപ്പോൾ ആ വേരിയബിളുകളിൽ ഏതെങ്കിലും ആക്സസ് ചെയ്യുമ്പോഴെല്ലാം, അതിന്റെ നിലവിലെ സിസ്റ്റം മുൻഗണനയാണ്
വീണ്ടെടുത്തു മടങ്ങി. ആ വേരിയബിളുകൾ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, പ്രക്രിയയുടെ മുൻഗണന ഇതാണ്
മാറി!

ഞങ്ങൾ Jarko Hietaniemi ഉപയോഗിക്കും[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>ന്റെ BSD::ആക്സസ്സുചെയ്യാൻ റിസോഴ്സ് ക്ലാസ് (ഉൾപ്പെടുത്തിയിട്ടില്ല).
നിങ്ങളുടെ സിസ്റ്റത്തിൽ നിന്നുള്ള PRIO_PROCESS, PRIO_MIN, PRIO_MAX സ്ഥിരാങ്കങ്ങൾ, അതുപോലെ
മുൻഗണന () ഒപ്പം മുൻഗണന() സിസ്റ്റം കോളുകൾ. ക്ലാസ്സിന്റെ ആമുഖം ഇതാ.

പാക്കേജ് നൈസ്;
കരിമീൻ ഉപയോഗിക്കുക;
BSD ഉപയോഗിക്കുക :: റിസോഴ്സ്;
കർശനമായി ഉപയോഗിക്കുക;
$Nice::DEBUG = 0 നിർവചിച്ചിട്ടില്ലെങ്കിൽ $Nice::DEBUG;

TIESCALAR ക്ലാസ്സ്‌നാമം, ലിസ്റ്റ്
ഇതാണ് ക്ലാസിന്റെ കൺസ്ട്രക്റ്റർ. അതിനർത്ഥം അത് അനുഗ്രഹീതമായി തിരിച്ചുവരുമെന്ന് പ്രതീക്ഷിക്കുന്നു എന്നാണ്
അത് സൃഷ്ടിക്കുന്ന ഒരു പുതിയ സ്കെയിലറിലേക്കുള്ള റഫറൻസ് (ഒരുപക്ഷേ അജ്ഞാതമായിരിക്കാം). ഉദാഹരണത്തിന്:

സബ് ടൈസ്‌കലാർ {
എന്റെ $ ക്ലാസ് = ഷിഫ്റ്റ്;
എന്റെ $pid = ഷിഫ്റ്റ് || $$; # 0 എന്നാൽ ഞാൻ എന്നാണ് അർത്ഥമാക്കുന്നത്

എങ്കിൽ ($pid !~ /^\d+$/) {
കരിമീൻ "Nice::Tie::Scalar ലഭിച്ചു നോൺ-ന്യൂമറിക് pid $pid" എങ്കിൽ $^W;
തിരികെ undef;
}

ഇല്ലെങ്കിൽ (0, $pid) { # EPERM അല്ലെങ്കിൽ ERSCH, സംശയമില്ല
കരിമീൻ "നല്ലത്:: ടൈ:: സ്കെലാർ മോശം പിഡ് $pid: $!" എങ്കിൽ $^W;
തിരികെ undef;
}

തിരികെ അനുഗ്രഹിക്കൂ \$pid, $ക്ലാസ്;
}

ഈ ടൈ ക്ലാസ് ഒരു പിശക് ഉണ്ടെങ്കിൽ അത് ഒഴിവാക്കുന്നതിന് പകരം അത് തിരികെ നൽകാൻ തിരഞ്ഞെടുത്തു
കൺസ്ട്രക്റ്റർ പരാജയപ്പെടണം. അതേസമയം ഇങ്ങനെ dbmopen() പ്രവർത്തിക്കുന്നു, മറ്റ് ക്ലാസുകൾ നന്നായി ചെയ്യാം
അങ്ങനെ ക്ഷമിക്കാൻ ആഗ്രഹിക്കുന്നില്ല. ഇത് പുറത്തുവിടണോ എന്നറിയാൻ ആഗോള വേരിയബിൾ $^W പരിശോധിക്കുന്നു
എന്തായാലും കുറച്ച് ബഹളം.

ഇത് കൊണ്ടുവരിക
ടൈഡ് വേരിയബിൾ ആക്‌സസ് ചെയ്യുമ്പോഴെല്ലാം ഈ രീതി പ്രവർത്തനക്ഷമമാകും (വായിക്കുക). അത്
അതിനെ പ്രതിനിധീകരിക്കുന്ന ഒബ്ജക്‌റ്റായ അതിന്റെ സെൽഫ് റഫറൻസിനപ്പുറം വാദങ്ങളൊന്നും എടുക്കുന്നില്ല
ഞങ്ങൾ കൈകാര്യം ചെയ്യുന്ന സ്കെയിലർ. കാരണം ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ ഒരു SCALAR ref ആണ് ഉപയോഗിക്കുന്നത്
കെട്ടിയ സ്കെയിലർ ഒബ്‌ജക്‌റ്റ്, ഒരു ലളിതമായ $$self സംഭരിച്ചിരിക്കുന്ന യഥാർത്ഥ മൂല്യം നേടുന്നതിന് രീതിയെ അനുവദിക്കുന്നു
അവിടെ. ചുവടെയുള്ള ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ബന്ധിപ്പിച്ചിരിക്കുന്ന പ്രോസസ്സ് ഐഡിയാണ് യഥാർത്ഥ മൂല്യം
ഞങ്ങളുടെ വേരിയബിൾ.

സബ് ഫെച്ച് {
എന്റെ $self = shift;
"തെറ്റായ തരം" ഏറ്റുപറയുക $self അല്ലാത്തപക്ഷം;
@_ എങ്കിൽ ക്രോക്ക് "ഉപയോഗ പിശക്";
എന്റെ $നല്ലത്;
ലോക്കൽ($!) = 0;
$nicety = getpriority(PRIO_PROCESS, $$self);
എങ്കിൽ ($!) { croak "getpriority Failed: $!" }
തിരികെ $nicety;
}

ഇത്തവണ റെനീസ് പരാജയപ്പെട്ടാൽ പൊട്ടിത്തെറിക്കാൻ (ഒരു അപവാദം ഉന്നയിക്കാൻ) ഞങ്ങൾ തീരുമാനിച്ചു--ഇവിടെയുണ്ട്
അല്ലാത്തപക്ഷം ഒരു പിശക് തിരികെ നൽകാൻ ഞങ്ങൾക്ക് സ്ഥലമില്ല, അത് ഒരുപക്ഷേ ശരിയായ കാര്യമാണ്.

ഇത് സംഭരിക്കുക, മൂല്യം
ടൈഡ് വേരിയബിൾ സജ്ജമാക്കുമ്പോൾ (അസൈൻ ചെയ്‌തത്) ഓരോ തവണയും ഈ രീതി പ്രവർത്തനക്ഷമമാകും. അപ്പുറം
അതിന്റെ സ്വയം റഫറൻസ്, അത് ഒരു (ഒരേയൊരു) വാദവും പ്രതീക്ഷിക്കുന്നു: പുതിയ മൂല്യം
ഉപയോക്താവ് അസൈൻ ചെയ്യാൻ ശ്രമിക്കുന്നു. സ്റ്റോറിൽ നിന്ന് ഒരു മൂല്യം തിരികെ നൽകുന്നതിനെക്കുറിച്ച് വിഷമിക്കേണ്ട; അർത്ഥശാസ്ത്രം
അസൈൻ ചെയ്‌ത മൂല്യം തിരികെ നൽകുന്ന അസൈൻമെന്റ് FETCH ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു.

ഉപ സ്റ്റോർ {
എന്റെ $self = shift;
"തെറ്റായ തരം" ഏറ്റുപറയുക $self അല്ലാത്തപക്ഷം;
എന്റെ $new_nicety = ഷിഫ്റ്റ്;
@_ എങ്കിൽ ക്രോക്ക് "ഉപയോഗ പിശക്";

എങ്കിൽ ($new_nicety < PRIO_MIN) {
കരിമീൻ സ്പ്രിന്റ്ഫ്
"മുന്നറിയിപ്പ്: മിനിമം സിസ്റ്റം മുൻ‌ഗണന %d എന്നതിനേക്കാൾ മുൻഗണന %d കുറവാണ്",
$new_nicety, PRIO_MIN ആണെങ്കിൽ $^W;
$new_nicety = PRIO_MIN;
}

എങ്കിൽ ($new_nicety > PRIO_MAX) {
കരിമീൻ സ്പ്രിന്റ്ഫ്
"മുന്നറിയിപ്പ്: മുൻ‌ഗണന %d പരമാവധി സിസ്റ്റം മുൻഗണനയേക്കാൾ %d കൂടുതലാണ്",
$new_nicety, PRIO_MAX ആണെങ്കിൽ $^W;
$new_nicety = PRIO_MAX;
}

അല്ലാതെ (നിർവചിച്ച സെറ്റ്പ്രോറിറ്റി(PRIO_PROCESS, $$self, $new_nicety)) {
ഏറ്റുപറയുക "മുൻഗണന പരാജയപ്പെട്ടു: $!";
}
}

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

ഇത് നശിപ്പിക്കുക
ടൈഡ് വേരിയബിൾ നശിപ്പിക്കേണ്ടിവരുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും. ഉള്ളതുപോലെ
മറ്റ് ഒബ്ജക്റ്റ് ക്ലാസുകളിൽ, അത്തരം ഒരു രീതി വളരെ അപൂർവമായി മാത്രമേ ആവശ്യമുള്ളൂ, കാരണം പേൾ അതിന്റെ ഡീലോക്കേറ്റ് ചെയ്യുന്നു
മോറിബണ്ട് ഒബ്‌ജക്‌റ്റിന്റെ മെമ്മറി നിങ്ങൾക്കായി സ്വയമേവ--ഇത് C++ അല്ല, നിങ്ങൾക്കറിയാം. ഞങ്ങൾ എ ഉപയോഗിക്കും
ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്കായി മാത്രം ഇവിടെ DESTROY രീതി.

ഉപ നശിപ്പിക്കുക {
എന്റെ $self = shift;
"തെറ്റായ തരം" ഏറ്റുപറയുക $self അല്ലാത്തപക്ഷം;
കരിമീൻ "[ Nice::DESTROY pid $$self ]" എങ്കിൽ $Nice ::DEBUG;
}

അത്രയേ ഉള്ളൂ. യഥാർത്ഥത്തിൽ, അത് അതിലുള്ള എല്ലാറ്റിനേക്കാളും കൂടുതലാണ്, കാരണം
പൂർണ്ണതയ്ക്കും ദൃഢതയ്ക്കും പൊതുവായതിനും വേണ്ടി ഞങ്ങൾ ഇവിടെ കുറച്ച് നല്ല കാര്യങ്ങൾ ചെയ്തിട്ടുണ്ട്
സൗന്ദര്യശാസ്ത്രം. ലളിതമായ TIESCALAR ക്ലാസുകൾ തീർച്ചയായും സാധ്യമാണ്.

കെട്ടുന്നു അറേ
ടൈഡ് ഓർഡിനറി അറേ നടപ്പിലാക്കുന്ന ഒരു ക്ലാസ് ഇനിപ്പറയുന്ന രീതികൾ നിർവചിക്കേണ്ടതാണ്: TIERRAY,
കൊണ്ടുവരിക, സംഭരിക്കുക, വലുപ്പം മാറ്റുക, സംഭരിക്കുക, മായ്ക്കുക, ഒരുപക്ഷേ അഴിക്കുക കൂടാതെ/അല്ലെങ്കിൽ നശിപ്പിക്കുക.

FETCHSIZE, STORESIZE എന്നിവ $#അറേയും തത്തുല്യമായ "scalar(@array)"യും നൽകാൻ ഉപയോഗിക്കുന്നു.
പ്രവേശനം.

പേൾ ആണെങ്കിൽ POP, പുഷ്, SHIFT, UNSHIFT, SPLICE, DELETE, EXISTS എന്നീ രീതികൾ ആവശ്യമാണ്
ബന്ധപ്പെട്ട (എന്നാൽ ചെറിയക്ഷരം) പേരുള്ള ഓപ്പറേറ്റർ ടൈഡ് അറേയിൽ പ്രവർത്തിക്കണം. ദി
ടൈ::അറേ ഇതിൽ ആദ്യത്തെ അഞ്ചെണ്ണം പദങ്ങളിൽ നടപ്പിലാക്കാൻ class അടിസ്ഥാന ക്ലാസ്സായി ഉപയോഗിക്കാം
മുകളിലുള്ള അടിസ്ഥാന രീതികളിൽ. DELETE, EXISTS എന്നിവയുടെ ഡിഫോൾട്ട് നടപ്പിലാക്കലുകൾ
ടൈ::അറേ ലളിതമായി "ക്രോക്ക്".

കൂടാതെ, perl ഒരു യഥാർത്ഥത്തിൽ മുൻകൂട്ടി വിപുലീകരിച്ച അലോക്കേഷൻ ഉള്ളപ്പോൾ EXTEND വിളിക്കും
അറേ.

ഈ ചർച്ചയ്‌ക്കായി, സൃഷ്‌ടിക്കുമ്പോൾ ഒരു നിശ്ചിത വലുപ്പത്തിലുള്ള ഘടകങ്ങൾ ഉള്ള ഒരു അറേ ഞങ്ങൾ നടപ്പിലാക്കും.
നിശ്ചിത വലുപ്പത്തേക്കാൾ വലിയ ഒരു ഘടകം സൃഷ്ടിക്കാൻ നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഒരു ഒഴിവാക്കൽ എടുക്കും. വേണ്ടി
ഉദാഹരണം:

FixedElem_Array ഉപയോഗിക്കുക;
tie @array, 'FixedElem_Array', 3;
$array[0] = 'പൂച്ച'; # ശരി.
$array[1] = 'നായകൾ'; # ഒഴിവാക്കൽ, നീളം('നായകൾ') > 3.

ക്ലാസിന്റെ ആമുഖ കോഡ് ഇപ്രകാരമാണ്:

പാക്കേജ് FixedElem_Array;
കരിമീൻ ഉപയോഗിക്കുക;
കർശനമായി ഉപയോഗിക്കുക;

TIERRAY ക്ലാസിന്റെ പേര്, ലിസ്റ്റ്
ഇതാണ് ക്ലാസിന്റെ കൺസ്ട്രക്റ്റർ. അതിനർത്ഥം അത് അനുഗ്രഹീതമായി തിരിച്ചുവരുമെന്ന് പ്രതീക്ഷിക്കുന്നു എന്നാണ്
റഫറൻസ് വഴിയാണ് പുതിയ അറേ (ഒരുപക്ഷേ ഒരു അജ്ഞാത അറേ റെഫർ) ഉണ്ടാകുന്നത്
ആക്സസ് ചെയ്തു.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, നിങ്ങൾ അങ്ങനെ ചെയ്യുന്നില്ലെന്ന് കാണിക്കാൻ ശരിക്കും ഒരു ARRAY തിരികെ നൽകണം
റഫറൻസ്, ഞങ്ങളുടെ വസ്തുവിനെ പ്രതിനിധീകരിക്കുന്നതിന് ഞങ്ങൾ ഒരു HASH റഫറൻസ് തിരഞ്ഞെടുക്കും. ഒരു ഹാഷ് പ്രവർത്തിക്കുന്നു
ഒരു സാധാരണ റെക്കോർഡ് തരം പോലെ: "{ELEMSIZE}" ഫീൽഡ് പരമാവധി ഘടകം സംഭരിക്കും
വലുപ്പം അനുവദനീയമാണ്, കൂടാതെ "{ARRAY}" ഫീൽഡിൽ യഥാർത്ഥ ARRAY റെഫറൻസ് ഉണ്ടായിരിക്കും. ആരെങ്കിലും എങ്കിൽ
ക്ലാസിന് പുറത്ത് തിരികെ വന്ന വസ്തുവിനെ അവഗണിക്കാൻ ശ്രമിക്കുന്നു (സംശയമില്ലാതെ അത് ചിന്തിക്കുന്നു
ARRAY ref), അവ പൊട്ടിത്തെറിക്കും. നിങ്ങൾ ബഹുമാനിക്കണമെന്ന് ഇത് കാണിക്കുന്നു
വസ്തുവിന്റെ സ്വകാര്യത.

ഉപ ടയർറേ {
എന്റെ $ ക്ലാസ് = ഷിഫ്റ്റ്;
എന്റെ $ elemsize = shift;
എങ്കിൽ (@_ || $elemsize =~ /\D/) {
ക്രോക്ക് "ഉപയോഗം: ടൈ അറേ, '" . __പാക്കേജ്__. "', elem_size";
}
തിരികെ അനുഗ്രഹിക്കൂ {
ELEMSIZE => $elemsize,
അറേ => [],
}, $ക്ലാസ്;
}

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

സബ് ഫെച്ച് {
എന്റെ $self = shift;
എന്റെ $ സൂചിക = ഷിഫ്റ്റ്;
തിരികെ $self->{ARRAY}->[$index];
}

ഒരു നിരയിൽ നിന്ന് വായിക്കാൻ നെഗറ്റീവ് അറേ സൂചിക ഉപയോഗിക്കുകയാണെങ്കിൽ, സൂചിക വിവർത്തനം ചെയ്യപ്പെടും
FETCH-ലേക്ക് കൈമാറുന്നതിന് മുമ്പ് FETCHSIZE എന്ന് വിളിച്ച് ആന്തരികമായി പോസിറ്റീവ് ഒന്നിലേക്ക്. നിങ്ങൾ
$NEGATIVE_INDICES എന്ന വേരിയബിളിന് യഥാർത്ഥ മൂല്യം നൽകി ഈ സവിശേഷത പ്രവർത്തനരഹിതമാക്കിയേക്കാം
ടൈഡ് അറേ ക്ലാസിൽ.

നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം, FETCH രീതിയുടെ പേര് (et al.) എല്ലാവർക്കും ഒരുപോലെയാണ്
കൺസ്ട്രക്‌ടറുകൾ പേരുകളിൽ വ്യത്യാസമുണ്ടെങ്കിലും ആക്‌സസ്സ് ചെയ്യുന്നു (TIESCALAR vs TIERRAY). അതേസമയം
സൈദ്ധാന്തികമായി, നിങ്ങൾക്ക് ഒരേ ക്ലാസിൽ നിരവധി ടൈഡ് തരങ്ങൾക്ക് സേവനം നൽകാം, പ്രായോഗികമായി ഇത്
ബുദ്ധിമുട്ടുള്ളതായി മാറുന്നു, ഓരോ ക്ലാസിലും ഒരു ടൈ തരത്തിൽ അവയെ നിലനിർത്തുന്നത് എളുപ്പമാണ്.

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

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, "undef" എന്നത് യഥാർത്ഥത്തിൽ "$self->{ELEMSIZE}" സ്‌പെയ്‌സുകളുടെ എണ്ണമാണ്, അതിനാൽ ഞങ്ങൾക്ക് ഒരു
ഇവിടെ കുറച്ച് ജോലി കൂടി ചെയ്യാനുണ്ട്:

ഉപ സ്റ്റോർ {
എന്റെ $self = shift;
എന്റെ ( $ സൂചിക, $ മൂല്യം ) = @_;
എങ്കിൽ (നീളം $value > $self->{ELEMSIZE} ) {
croak "$value-ന്റെ ദൈർഘ്യം $self->{ELEMSIZE} എന്നതിനേക്കാൾ വലുതാണ്";
}
# വിട്ട ഭാഗം പൂരിപ്പിക്കുക
$self->EXTEND( $index ) എങ്കിൽ $index > $self->FETCHSIZE();
# ചെറിയ മൂലകങ്ങൾക്ക് മൂലകത്തിന്റെ വലുപ്പം നിലനിർത്താൻ ശരിയായ ന്യായീകരണം
$self->{ARRAY}->[$index] = sprintf "%$self->{ELEMSIZE}s", $value;
}

നെഗറ്റീവ് സൂചികകൾ FETCH പോലെ തന്നെ പരിഗണിക്കുന്നു.

ഇത് വലുപ്പം മാറ്റുക
ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെട്ട ടൈഡ് അറേയിലെ മൊത്തം ഇനങ്ങളുടെ എണ്ണം നൽകുന്നു ഈ.
("scalar(@array)" എന്നതിന് തുല്യം). ഉദാഹരണത്തിന്:

ഉപ FETCHSIZE {
എന്റെ $self = shift;
റിട്ടേൺ സ്കെലാർ @{$self->{ARRAY}};
}

ഇത് സംഭരിക്കുക, എണ്ണുക
ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെട്ട ടൈഡ് അറേയിലെ മൊത്തം ഇനങ്ങളുടെ എണ്ണം സജ്ജീകരിക്കുന്നു ഈ ആയിരിക്കാൻ
എണ്ണുക. ഇത് അറേയെ വലുതാക്കിയാൽ ക്ലാസ്സിന്റെ "undef" മാപ്പിംഗ് ആയിരിക്കണം
പുതിയ സ്ഥാനങ്ങളിലേക്ക് മടങ്ങി. അറേ ചെറുതാകുകയാണെങ്കിൽ, എൻട്രികൾ എണ്ണത്തിന് അപ്പുറമാണ്
ഇല്ലാതാക്കണം.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, 'undef' എന്നത് യഥാർത്ഥത്തിൽ "$self->{ELEMSIZE}" എണ്ണം ഉൾക്കൊള്ളുന്ന ഒരു ഘടകമാണ്
ഇടങ്ങൾ. നിരീക്ഷിക്കുക:

ഉപ സ്റ്റോർസൈസ് {
എന്റെ $self = shift;
എന്റെ $എണ്ണം = ഷിഫ്റ്റ്;
എങ്കിൽ ($count > $self->FETCHSIZE() ) {
foreach ($count - $self->FETCHSIZE() .. $count ) {
$self->സ്റ്റോർ( $_, '' );
}
} elsif ($count < $self->FETCHSIZE() ) {
foreach ( 0 .. $self->FETCHSIZE() - $count - 2 ) {
$self->POP();
}
}
}

ഇത് വിപുലീകരിക്കുക, എണ്ണുക
വിജ്ഞാനപ്രദമായ കോൾ ആ ശ്രേണി വളരാൻ സാധ്യതയുണ്ട് എണ്ണുക എൻട്രികൾ. ഉപയോഗിക്കാവുന്നതാണ്
വിഹിതം ഒപ്റ്റിമൈസ് ചെയ്യുക. ഈ രീതി ഒന്നും ചെയ്യേണ്ടതില്ല.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ശൂന്യമായ ("undef") എൻട്രികൾ ഇല്ലെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അതിനാൽ "വിപുലീകരിക്കുക"
ആവശ്യമുള്ള ഘടകങ്ങൾ പൂരിപ്പിക്കുന്നതിന് "സ്റ്റോർസൈസ്" ഉപയോഗിക്കും:

ഉപ വിപുലീകരണം {
എന്റെ $self = shift;
എന്റെ $എണ്ണം = ഷിഫ്റ്റ്;
$self->STORESIZE($count );
}

ഇത് നിലവിലുണ്ട്, കീ
സൂചികയിലെ മൂലകമാണോ എന്ന് പരിശോധിക്കുക കീ ടൈഡ് അറേയിൽ നിലവിലുണ്ട് ഈ.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഒരു ഘടകത്തിൽ "$self->{ELEMSIZE}" അടങ്ങിയിട്ടുണ്ടോ എന്ന് ഞങ്ങൾ നിർണ്ണയിക്കും
ഇടങ്ങൾ മാത്രം, അത് നിലവിലില്ല:

ഉപ നിലവിലുണ്ട് {
എന്റെ $self = shift;
എന്റെ $ സൂചിക = ഷിഫ്റ്റ്;
എങ്കിൽ 0 തിരികെ നൽകുക! നിർവചിച്ച $self->{ARRAY}->[$index] ||
$self->{ARRAY}->[$index] eq ' ' x $self->{ELEMSIZE};
തിരികെ വരുക;
}

ഇത് ഇല്ലാതാക്കുക, കീ
സൂചികയിലെ ഘടകം ഇല്ലാതാക്കുക കീ കെട്ടിയ അറേയിൽ നിന്ന് ഈ.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഇല്ലാതാക്കിയ ഒരു ഇനം "$self->{ELEMSIZE}" സ്‌പെയ്‌സുകളാണ്:

ഉപ ഇല്ലാതാക്കുക {
എന്റെ $self = shift;
എന്റെ $ സൂചിക = ഷിഫ്റ്റ്;
തിരികെ $self->സ്റ്റോർ( $index, '' );
}

ഇത് ക്ലിയർ ചെയ്യുക
ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെട്ട ടൈഡ് അറേയിൽ നിന്ന് എല്ലാ മൂല്യങ്ങളും മായ്‌ക്കുക (നീക്കം ചെയ്യുക, ഇല്ലാതാക്കുക, ...).
ഈ. ഉദാഹരണത്തിന്:

സബ് ക്ലിയർ {
എന്റെ $self = shift;
തിരികെ $self->{ARRAY} = [];
}

ഇത് പുഷ് ചെയ്യുക, ലിസ്റ്റ്
എന്നതിന്റെ ഘടകങ്ങൾ കൂട്ടിച്ചേർക്കുക പട്ടിക അറേയിലേക്ക്. ഉദാഹരണത്തിന്:

ഉപ പുഷ് {
എന്റെ $self = shift;
എന്റെ @ലിസ്റ്റ് = @_;
എന്റെ $ലാസ്റ്റ് = $self->FETCHSIZE();
$self->സ്റ്റോർ( $last + $_, $list[$_] ) foreach 0 .. $#list;
$self->FETCHSIZE();
}

ഇത് പോപ്പ് ചെയ്യുക
അറേയുടെ അവസാന ഘടകം നീക്കം ചെയ്‌ത് തിരികെ നൽകുക. ഉദാഹരണത്തിന്:

ഉപ POP {
എന്റെ $self = shift;
റിട്ടേൺ പോപ്പ് @{$self->{ARRAY}};
}

ഇത് മാറ്റുക
അറേയുടെ ആദ്യ ഘടകം നീക്കം ചെയ്യുക (മറ്റ് ഘടകങ്ങൾ താഴേക്ക് മാറ്റുക) അത് തിരികെ നൽകുക.
ഉദാഹരണത്തിന്:

ഉപ ഷിഫ്റ്റ് {
എന്റെ $self = shift;
റിട്ടേൺ ഷിഫ്റ്റ് @{$self->{ARRAY}};
}

ഇത് മാറ്റുക, ലിസ്റ്റ്
അറേയുടെ തുടക്കത്തിൽ LIST ഘടകങ്ങൾ ചേർക്കുക, നിലവിലുള്ള ഘടകങ്ങൾ മുകളിലേക്ക് നീക്കുക
മുറി ഉണ്ടാക്കുക. ഉദാഹരണത്തിന്:

ഉപ UNSHIFT {
എന്റെ $self = shift;
എന്റെ @ലിസ്റ്റ് = @_;
എന്റെ $ വലിപ്പം = സ്കെയിലർ (@ലിസ്റ്റ്);
# ഞങ്ങളുടെ ലിസ്റ്റിന് ഇടം നൽകുക
@{$self->{ARRAY}}[ $size .. $#{$self->{ARRAY}} + $size ]
= @{$self->{ARRAY}};
$self->സ്റ്റോർ( $_, $list[$_] ) foreach 0 .. $#list;
}

ഇത് സ്‌പ്ലൈസ് ചെയ്യുക, ഓഫ്‌സെറ്റ്, ദൈർഘ്യം, ലിസ്റ്റ്
അറേയിൽ "സ്‌പ്ലൈസ്" എന്നതിന് തുല്യമായ പ്രകടനം നടത്തുക.

ഓഫ്സെറ്റ് ഓപ്ഷണൽ ആണ്, പൂജ്യത്തിലേക്ക് ഡിഫോൾട്ടാണ്, നെഗറ്റീവ് മൂല്യങ്ങൾ അവസാനം മുതൽ കണക്കാക്കുന്നു
ശ്രേണി.

നീളം ഓപ്ഷണൽ ആണ്, അറേയുടെ ബാക്കി ഭാഗങ്ങളിൽ ഡിഫോൾട്ടാണ്.

പട്ടിക ശൂന്യമായിരിക്കാം.

ഒറിജിനലിന്റെ ഒരു ലിസ്റ്റ് നൽകുന്നു നീളം മൂലകങ്ങൾ ഓഫ്സെറ്റ്.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഒരു കുറുക്കുവഴി ഉണ്ടെങ്കിൽ ഞങ്ങൾ ഒരു ചെറിയ കുറുക്കുവഴി ഉപയോഗിക്കും പട്ടിക:

ഉപ SPLICE {
എന്റെ $self = shift;
എന്റെ $ഓഫ്സെറ്റ് = ഷിഫ്റ്റ് || 0;
എന്റെ $നീളം = ഷിഫ്റ്റ് || $self->FETCHSIZE() - $offset;
എന്റെ @ലിസ്റ്റ് = ();
എങ്കിൽ (@_) {
tie @list, __PACKAGE__, $self->{ELEMSIZE};
@ലിസ്റ്റ് = @_;
}
റിട്ടേൺ സ്‌പ്ലൈസ് @{$self->{ARRAY}}, $ഓഫ്‌സെറ്റ്, $ലെങ്ത്, @ലിസ്റ്റ്;
}

ഇത് UNTIE ചെയ്യുക
"കെട്ടഴിച്ചാൽ" ​​വിളിക്കും. (ചുവടെയുള്ള "അഴിയുക" ഗോച്ച" കാണുക.)

ഇത് നശിപ്പിക്കുക
ടൈഡ് വേരിയബിൾ നശിപ്പിക്കേണ്ടിവരുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും. ഉള്ളതുപോലെ
സ്കെയിലർ ടൈ ക്ലാസ്, സ്വന്തമായി ചെയ്യുന്ന ഒരു ഭാഷയിൽ ഇത് മിക്കവാറും ആവശ്യമില്ല
മാലിന്യ ശേഖരണം, അതിനാൽ ഇത്തവണ ഞങ്ങൾ അത് ഉപേക്ഷിക്കും.

കെട്ടുന്നു ഹാഷുകൾ
ടൈപ്പ് ചെയ്യപ്പെട്ട ആദ്യത്തെ പേൾ ഡാറ്റ തരം ഹാഷുകളാണ് (കാണുക dbmopen()). ഒരു ക്ലാസ് നടപ്പിലാക്കുന്നത് എ
ടൈഡ് ഹാഷ് ഇനിപ്പറയുന്ന രീതികൾ നിർവചിക്കേണ്ടതാണ്: TIEHASH ആണ് കൺസ്ട്രക്റ്റർ. FETCH ഒപ്പം
STORE കീയും മൂല്യ ജോഡികളും ആക്സസ് ചെയ്യുക. ഇതിൽ ഒരു കീ ഉണ്ടോ എന്ന് EXISTS റിപ്പോർട്ട് ചെയ്യുന്നു
ഹാഷ്, DELETE എന്നിവ ഒന്ന് ഇല്ലാതാക്കുന്നു. എല്ലാ കീയും മൂല്യവും ഇല്ലാതാക്കിക്കൊണ്ട് CLEAR ഹാഷ് ശൂന്യമാക്കുന്നു
ജോഡികൾ. FIRSTKEY, NEXTKEY എന്നിവ നടപ്പിലാക്കുന്നു കീകൾ() ഒപ്പം ഓരോ () എല്ലാത്തിലും ആവർത്തിക്കാനുള്ള പ്രവർത്തനങ്ങൾ
താക്കോലുകൾ. സ്കെയിലർ സന്ദർഭത്തിൽ ടൈഡ് ഹാഷ് മൂല്യനിർണ്ണയം ചെയ്യുമ്പോൾ SCALAR പ്രവർത്തനക്ഷമമാകുന്നു. UNTIE ആണ്
"കെട്ടഴിച്ചാൽ" ​​എന്ന് വിളിക്കപ്പെടുന്നു, കെട്ടിയ വേരിയബിൾ മാലിന്യമാകുമ്പോൾ DESTROY എന്ന് വിളിക്കുന്നു
ശേഖരിച്ചു.

ഇത് വളരെയേറെയാണെന്ന് തോന്നുകയാണെങ്കിൽ, സാധാരണ ടൈയിൽ നിന്ന് മാത്രം അനന്തരാവകാശം നേടാൻ മടിക്കേണ്ടതില്ല ::StdHash
നിങ്ങളുടെ മിക്ക രീതികൾക്കും മൊഡ്യൂൾ, രസകരമായവ മാത്രം പുനർ നിർവചിക്കുന്നു. ടൈ::ഹാഷ് എന്നതിനുള്ള കാണുക
വിശദാംശങ്ങൾ.

ഹാഷിൽ നിലവിലില്ലാത്ത ഒരു കീയും കീയും തമ്മിൽ Perl വേർതിരിക്കുന്നതായി ഓർക്കുക
ഹാഷിൽ നിലവിലുണ്ടെങ്കിലും "undef" ന്റെ അനുബന്ധ മൂല്യമുണ്ട്. രണ്ട് സാധ്യതകൾ
"exist()", "defined()" എന്നീ ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് പരീക്ഷിക്കാവുന്നതാണ്.

കുറച്ച് രസകരമായ ടൈഡ് ഹാഷ് ക്ലാസിന്റെ ഒരു ഉദാഹരണം ഇതാ: ഇത് നിങ്ങൾക്ക് ഒരു ഹാഷ് നൽകുന്നു
ഒരു പ്രത്യേക ഉപയോക്താവിന്റെ ഡോട്ട് ഫയലുകളെ പ്രതിനിധീകരിക്കുന്നു. എന്ന പേരിൽ നിങ്ങൾ ഹാഷിലേക്ക് സൂചികയിടുന്നു
ഫയൽ (ഡോട്ട് മൈനസ്) ആ ഡോട്ട് ഫയലിന്റെ ഉള്ളടക്കം നിങ്ങൾക്ക് തിരികെ ലഭിക്കും. ഉദാഹരണത്തിന്:

DotFiles ഉപയോഗിക്കുക;
ടൈ %dot, 'DotFiles';
എങ്കിൽ ( $dot{profile} =~ /MANPATH/ ||
$dot{login} =~ /MANPATH/ ||
$dot{cshrc} =~ /MANPATH/)
{
"നിങ്ങൾ നിങ്ങളുടെ മൻപത്ത് സജ്ജമാക്കുന്നതായി തോന്നുന്നു\n";
}

അല്ലെങ്കിൽ ഞങ്ങളുടെ ടൈഡ് ക്ലാസ് ഉപയോഗിക്കുന്നതിന്റെ മറ്റൊരു സാമ്പിൾ ഇതാ:

ടൈ % ഹിം, 'ഡോട്ട്ഫയലുകൾ', 'ഡെമൺ';
foreach $f (കീകൾ %ഹിം) {
printf "ഡെമൺ ഡോട്ട് ഫയൽ %s വലുപ്പം %d\n" ആണ്,
$f, നീളം $him{$f};
}

ഞങ്ങളുടെ ടൈഡ് ഹാഷ് ഡോട്ട്ഫയലുകൾ ഉദാഹരണത്തിൽ, നിരവധി അടങ്ങിയിരിക്കുന്ന ഒബ്ജക്റ്റിനായി ഞങ്ങൾ ഒരു സാധാരണ ഹാഷ് ഉപയോഗിക്കുന്നു
പ്രധാനപ്പെട്ട ഫീൽഡുകൾ, അതിൽ "{LIST}" ഫീൽഡ് മാത്രമേ ഉപയോക്താവ് കരുതുന്നുള്ളൂ
യഥാർത്ഥ ഹാഷ്.

ഈ ഒബ്‌ജക്‌റ്റ് പ്രതിനിധീകരിക്കുന്ന ഡോട്ട് ഫയലുകളുടെ USER

ആ ഡോട്ട് ഫയലുകൾ താമസിക്കുന്ന ഹോം

ക്ലോബ്ബർ
ആ ഡോട്ട് ഫയലുകൾ മാറ്റാനോ നീക്കം ചെയ്യാനോ ശ്രമിക്കണമോ എന്ന്

ഡോട്ട് ഫയൽ നാമങ്ങളുടെയും ഉള്ളടക്ക മാപ്പിംഗുകളുടെയും ഹാഷ് ലിസ്റ്റ് ചെയ്യുക

ഇതാ തുടക്കം Dotfiles.pm:

പാക്കേജ് ഡോട്ട്ഫയലുകൾ;
കരിമീൻ ഉപയോഗിക്കുക;
സബ് ഹൂവാസി { (വിളിക്കുന്നയാൾ(1))[3] . '()'}
എന്റെ $DEBUG = 0;
സബ് ഡീബഗ് {$DEBUG = @_ ? ഷിഫ്റ്റ് : 1 }

ഞങ്ങളുടെ ഉദാഹരണത്തിന്, ഈ സമയത്ത് കണ്ടെത്തുന്നതിന് സഹായിക്കുന്നതിന് ഡീബഗ്ഗിംഗ് വിവരങ്ങൾ പുറത്തുവിടാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
വികസനം. പ്രിന്റ് ഔട്ട് ചെയ്യാൻ സഹായിക്കുന്നതിന് ഞങ്ങൾ ഒരു സൗകര്യപ്രദമായ ഫംഗ്‌ഷൻ ആന്തരികമായി സൂക്ഷിക്കുന്നു
മുന്നറിയിപ്പുകൾ; ഹൂവാസി() അതിനെ വിളിക്കുന്ന ഫംഗ്‌ഷൻ നാമം നൽകുന്നു.

DotFiles ടൈഡ് ഹാഷിനുള്ള രീതികൾ ഇതാ.

TIEHASH ക്ലാസിന്റെ പേര്, പട്ടിക
ഇതാണ് ക്ലാസിന്റെ കൺസ്ട്രക്റ്റർ. അതിനർത്ഥം അത് അനുഗ്രഹീതമായി തിരിച്ചുവരുമെന്ന് പ്രതീക്ഷിക്കുന്നു എന്നാണ്
പുതിയ ഒബ്‌ജക്‌റ്റ് (ഒരുപക്ഷേ, പക്ഷേ ഒരു അജ്ഞാതമായിരിക്കണമെന്നില്ല
ഹാഷ്) ആക്സസ് ചെയ്യപ്പെടും.

കൺസ്ട്രക്റ്റർ ഇതാ:

ഉപ TIEHASH {
എന്റെ $self = shift;
എന്റെ $ഉപയോക്താവ് = ഷിഫ്റ്റ് || $>;
എന്റെ $dotdir = ഷിഫ്റ്റ് || '';
croak "ഉപയോഗം: @{[&whowasi]} [USER [DOTDIR]]" എങ്കിൽ @_;
$user = getpwuid($user) എങ്കിൽ $user =~ /^\d+$/;
എന്റെ $dir = (getpwnam($user))[7]
|| croak "@{[&whowasi]}: ഉപയോക്താവില്ല $user";
$dir .= "/$dotdir" എങ്കിൽ $dotdir;

എന്റെ $നോഡ് = {
USER => $ഉപയോക്താവ്,
വീട് => $dir,
ലിസ്റ്റ് => {},
CLOBBER => 0,
};

ഓപ്പൺഡിർ (DIR, $dir)
|| ക്രോക്ക് "@{[&whowasi]}: തുറക്കാൻ കഴിയില്ല $dir: $!";
foreach $dot ( grep /^\./ && -f "$dir/$_", readdir(DIR)) {
$dot =~ s/^\.//;
$node->{LIST}{$dot} = undef;
}
അടച്ചു DIR;
തിരികെ അനുഗ്രഹിക്കുക $നോഡ്, $self;
}

നിങ്ങൾ റിട്ടേൺ മൂല്യങ്ങൾ ഫയൽ ടെസ്റ്റ് ചെയ്യാൻ പോകുകയാണെങ്കിൽ അത് പരാമർശിക്കേണ്ടതാണ്
ഒരു വായനക്കാരന്റെ, സംശയാസ്‌പദമായ ഡയറക്‌ടറി നിങ്ങൾ മുൻകൂട്ടി തയ്യാറാക്കുന്നതാണ് നല്ലത്. അല്ലെങ്കിൽ, കാരണം ഞങ്ങൾ
ചെയ്തില്ല chdir() അവിടെ, അത് തെറ്റായ ഫയൽ പരീക്ഷിക്കുമായിരുന്നു.

ഇത് കൊണ്ടുവരിക, കീ
ടൈഡ് ഹാഷിലെ ഒരു ഘടകം ആക്‌സസ് ചെയ്യുമ്പോഴെല്ലാം ഈ രീതി പ്രവർത്തനക്ഷമമാകും
(വായിക്കുക). ഇത് അതിന്റെ സ്വയം റഫറൻസിനപ്പുറം ഒരു വാദം എടുക്കുന്നു: നമ്മൾ ആരുടെ മൂല്യമാണ്
കൊണ്ടുവരാൻ ശ്രമിക്കുന്നു.

ഞങ്ങളുടെ DotFiles ഉദാഹരണത്തിനായി ഇവിടെയുണ്ട്.

സബ് ഫെച്ച് {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
എന്റെ $ ഡോട്ട് = ഷിഫ്റ്റ്;
എന്റെ $dir = $self->{HOME};
എന്റെ $ഫയൽ = "$dir/.$dot";

(നിലവിലില്ല $self->{LIST}->{$dot} || -f $file) {
കാർപ്പ് "@{[&whowasi]}: $DEBUG ആണെങ്കിൽ $dot ഫയൽ ഇല്ല";
തിരികെ undef;
}

എങ്കിൽ ($self->{LIST}->{$dot}) {
$self->{LIST}->{$dot} തിരികെ നൽകുക;
} else {
തിരികെ $self->{LIST}->{$dot} = `പൂച്ച $dir/.$dot`;
}
}

യുണിക്സ് എന്ന് വിളിക്കുന്നത് കൊണ്ട് എഴുതാൻ എളുപ്പമായിരുന്നു പൂച്ച(1) കമാൻഡ്, പക്ഷേ അത് ഒരുപക്ഷേ
ഫയൽ സ്വമേധയാ തുറക്കാൻ കൂടുതൽ പോർട്ടബിൾ ആയിരിക്കുക (കൂടുതൽ കൂടുതൽ കാര്യക്ഷമമായി). തീർച്ചയായും,
ഡോട്ട് ഫയലുകൾ ഒരു Unixy ആശയമായതിനാൽ, ഞങ്ങൾ അത്ര ആശങ്കപ്പെടുന്നില്ല.

ഇത് സംഭരിക്കുക, കീ, മൂല്യം
ടൈഡ് ഹാഷിൽ ഒരു ഘടകം സജ്ജീകരിക്കുമ്പോൾ (എഴുതുമ്പോൾ) ഓരോ തവണയും ഈ രീതി പ്രവർത്തനക്ഷമമാകും.
അതിന്റെ സെൽഫ് റഫറൻസിനപ്പുറം രണ്ട് ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ്: നമ്മൾ ശ്രമിക്കുന്ന സൂചിക
എന്തെങ്കിലും സംഭരിക്കുക, ഞങ്ങൾ അവിടെ സ്ഥാപിക്കാൻ ശ്രമിക്കുന്ന മൂല്യം.

ഇവിടെ ഞങ്ങളുടെ DotFiles ഉദാഹരണത്തിൽ, തിരുത്തിയെഴുതാൻ അവരെ അനുവദിക്കാതിരിക്കാൻ ഞങ്ങൾ ശ്രദ്ധിക്കും
അവർ വിളിച്ചിട്ടില്ലെങ്കിൽ ഫയൽ ക്ലോബ്ബർ() യഥാർത്ഥ ഒബ്ജക്റ്റ് റഫറൻസിലെ രീതി
വഴി തിരിച്ചു ടൈ().

ഉപ സ്റ്റോർ {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
എന്റെ $ ഡോട്ട് = ഷിഫ്റ്റ്;
എന്റെ $ മൂല്യം = ഷിഫ്റ്റ്;
എന്റെ $file = $self->{HOME} . "/.$dot";
എന്റെ $user = $self->{USER};

ക്രോക്ക് "@{[&whowasi]}: $file clobberable അല്ല"
$self->{CLOBBER} ഒഴികെ;

തുറക്കുക(എന്റെ $f, '>', $ഫയൽ) || ക്രോക്ക് "$ ഫയൽ തുറക്കാൻ കഴിയില്ല: $!";
$f $value അച്ചടിക്കുക;
അടയ്ക്കുക($f);
}

അവർ എന്തെങ്കിലും കബളിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, അവർ പറഞ്ഞേക്കാം:

$ob = tie %daemon_dots, 'demon';
$ob->ക്ലോബ്ബർ(1);
$daemon_dots{signature} = "ഒരു യഥാർത്ഥ ഡെമൺ\n";

അണ്ടർലയിങ്ങ് ഒബ്ജക്റ്റിന്റെ റഫറൻസിൽ കൈ വയ്ക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം ഉപയോഗിക്കുക എന്നതാണ് കെട്ടി ()
ഫംഗ്‌ഷൻ, അതിനാൽ അവർ ഇതുപയോഗിച്ച് ക്ലോബ്ബർ സജ്ജീകരിച്ചിരിക്കാം:

ടൈ %daemon_dots, 'demon';
tied(%daemon_dots)->ക്ലോബ്ബർ(1);

ക്ലോബർ രീതി ലളിതമാണ്:

സബ് ക്ലോബ്ബർ {
എന്റെ $self = shift;
$self->{CLOBBER} = @_ ? shift : 1;
}

ഇത് ഇല്ലാതാക്കുക, കീ
സാധാരണയായി ഉപയോഗിക്കുന്നതിലൂടെ, ഹാഷിൽ നിന്ന് ഒരു ഘടകം നീക്കം ചെയ്യുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും
The ഇല്ലാതാക്കുക() പ്രവർത്തനം. വീണ്ടും, അവർ ശരിക്കും ആഗ്രഹിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ശ്രദ്ധിക്കും
ക്ലോബ്ബർ ഫയലുകൾ.

ഉപ ഇല്ലാതാക്കുക {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;

എന്റെ $self = shift;
എന്റെ $ ഡോട്ട് = ഷിഫ്റ്റ്;
എന്റെ $file = $self->{HOME} . "/.$dot";
croak "@{[&whowasi]}: ഫയൽ $file നീക്കം ചെയ്യില്ല"
$self->{CLOBBER} ഒഴികെ;
$self->{LIST}->{$dot} ഇല്ലാതാക്കുക;
എന്റെ $വിജയം = അൺലിങ്ക് ($ഫയൽ);
carp "@{[&whowasi]}: $ഫയൽ അൺലിങ്ക് ചെയ്യാൻ കഴിയില്ല: $!" $വിജയം ഒഴികെ;
$വിജയം;
}

DELETE നൽകുന്ന മൂല്യം, ഇതിലേക്കുള്ള കോളിന്റെ റിട്ടേൺ മൂല്യമായി മാറുന്നു ഇല്ലാതാക്കുക(). നിങ്ങൾ എങ്കിൽ
യുടെ സാധാരണ സ്വഭാവം അനുകരിക്കാൻ ആഗ്രഹിക്കുന്നു ഇല്ലാതാക്കുക(), നിങ്ങൾ എന്ത് എടുത്താലും തിരികെ നൽകണം
ഈ താക്കോലിനായി മടങ്ങിവരുമായിരുന്നു. ഈ ഉദാഹരണത്തിൽ, ഒരു റിട്ടേൺ നൽകുന്നതിന് പകരം ഞങ്ങൾ തിരഞ്ഞെടുത്തു
ഫയൽ വിജയകരമായി ഇല്ലാതാക്കിയിട്ടുണ്ടോ എന്ന് വിളിക്കുന്നയാളോട് പറയുന്ന മൂല്യം.

ഇത് ക്ലിയർ ചെയ്യുക
സാധാരണയായി അസൈൻ ചെയ്യുന്നതിലൂടെ മുഴുവൻ ഹാഷും മായ്‌ക്കപ്പെടുമ്പോൾ ഈ രീതി ട്രിഗർ ചെയ്യപ്പെടും
അതിലേക്കുള്ള ശൂന്യമായ ലിസ്റ്റ്.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, അത് ഉപയോക്താവിന്റെ എല്ലാ ഡോട്ട് ഫയലുകളും നീക്കം ചെയ്യും! അത്ര അപകടകരമാണ്
അത് സാധ്യമാക്കാൻ അവർ 1-നേക്കാൾ ഉയർന്ന ഒന്നിലേക്ക് CLOBBER സജ്ജീകരിക്കേണ്ടി വരും.

സബ് ക്ലിയർ {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
croak "@{[&whowasi]}: $self->{USER} എന്നതിനായുള്ള എല്ലാ ഡോട്ട് ഫയലുകളും നീക്കം ചെയ്യില്ല
$self->{CLOBBER} > 1 ഒഴികെ;
എന്റെ $ ഡോട്ട്;
ഫോർച്ച് $dot ( കീകൾ %{$self->{LIST}}) {
$self->ഇല്ലാതാക്കുക($dot);
}
}

ഇത് നിലവിലുണ്ട്, കീ
ഉപയോക്താവ് ഉപയോഗിക്കുമ്പോൾ ഈ രീതി ട്രിഗർ ചെയ്യപ്പെടുന്നു നിലവിലുണ്ട് () ഒരു പ്രത്യേക പ്രവർത്തനത്തിൽ
ഹാഷ്. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഇതിനായി ഞങ്ങൾ "{LIST}" ഹാഷ് ഘടകം നോക്കും:

ഉപ നിലവിലുണ്ട് {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
എന്റെ $ ഡോട്ട് = ഷിഫ്റ്റ്;
റിട്ടേൺ നിലവിലുണ്ട് $self->{LIST}->{$dot};
}

ഇത് ആദ്യം
ഉപയോക്താവ് ഹാഷിലൂടെ ആവർത്തിക്കാൻ പോകുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും
ഒരു വഴി പോലെ കീകൾ(), മൂല്യങ്ങൾ (), അഥവാ ഓരോ () വിളി.

ഉപ ആദ്യകീ {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
എന്റെ $a = കീകൾ %{$self->{LIST}}; # ഓരോ() ഇറ്ററേറ്ററും പുനഃസജ്ജമാക്കുക
ഓരോ %{$self->{LIST}}
}

FIRSTKEY എന്നത് എല്ലായ്പ്പോഴും സ്കെയിലർ സന്ദർഭത്തിലാണ് വിളിക്കുന്നത്, അത് ആദ്യത്തെ കീ നൽകണം.
മൂല്യങ്ങൾ (), ഒപ്പം ഓരോ () ലിസ്റ്റ് സന്ദർഭത്തിൽ, തിരികെ നൽകിയ കീകൾക്കായി FETCH-നെ വിളിക്കും.

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

NEXTKEY എപ്പോഴും സ്കെയിലർ സന്ദർഭത്തിലാണ് വിളിക്കുന്നത്, അത് അടുത്ത കീ നൽകണം.
മൂല്യങ്ങൾ (), ഒപ്പം ഓരോ () ലിസ്റ്റ് സന്ദർഭത്തിൽ, തിരികെ നൽകിയ കീകൾക്കായി FETCH-നെ വിളിക്കും.

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

ഉപ അടുത്തത് {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
ഓരോ %{ $self->{LIST}} എന്നതും തിരികെ നൽകുക
}

ഇത് സ്കെയിലർ ചെയ്യുക
സ്കെയിലർ സന്ദർഭത്തിൽ ഹാഷ് വിലയിരുത്തുമ്പോൾ ഇതിനെ വിളിക്കുന്നു. അനുകരിക്കാൻ വേണ്ടി
അൺടൈഡ് ഹാഷുകളുടെ പെരുമാറ്റം, ഈ രീതി ടൈഡ് ഹാഷ് ചെയ്യുമ്പോൾ തെറ്റായ മൂല്യം നൽകണം
ശൂന്യമായി കണക്കാക്കപ്പെടുന്നു. ഈ രീതി നിലവിലില്ലെങ്കിൽ, perl ചിലരെ വിദ്യാസമ്പന്നരാക്കും
ഹാഷ് ഒരു ആവർത്തനത്തിനുള്ളിൽ ആയിരിക്കുമ്പോൾ ഊഹിക്കുകയും ശരിയാക്കുകയും ചെയ്യുക. ഇത് അങ്ങനെയല്ലെങ്കിൽ,
FIRSTKEY എന്ന് വിളിക്കുന്നു, FIRSTKEY ശൂന്യമായത് തിരികെ നൽകിയാൽ ഫലം തെറ്റായ മൂല്യമായിരിക്കും.
പട്ടിക, അല്ലെങ്കിൽ ശരി.

എന്നിരുന്നാലും, നിങ്ങൾ ചെയ്യണം അല്ല എല്ലായ്പ്പോഴും ശരിയായ കാര്യം ചെയ്യുന്ന perl-നെ അന്ധമായി ആശ്രയിക്കുക.
പ്രത്യേകിച്ചും, നിങ്ങൾ ആവർത്തിച്ച് ഹാഷ് മായ്‌ക്കുമ്പോൾ perl തെറ്റായി true ആയി നൽകും
അത് ശൂന്യമാകുന്നത് വരെ DELETE എന്ന് വിളിക്കുന്നു. അതിനാൽ നിങ്ങളുടെ സ്വന്തം SCALAR നൽകാൻ നിങ്ങളോട് നിർദ്ദേശിക്കുന്നു
നിങ്ങളുടെ ഹാഷ് സ്കെയിലറിൽ നന്നായി പെരുമാറുന്നുവെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടായിരിക്കണമെങ്കിൽ രീതി
സന്ദർഭം.

നമ്മുടെ ഉദാഹരണത്തിൽ, റഫറൻസ് ചെയ്തിരിക്കുന്ന അടിസ്ഥാന ഹാഷിൽ നമുക്ക് "സ്കെലാർ" എന്ന് വിളിക്കാം
"$self->{LIST}":

ഉപ സ്കെയിലർ {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
എന്റെ $self = shift;
റിട്ടേൺ സ്കെയിലർ %{ $self->{LIST}}
}

ഇത് UNTIE ചെയ്യുക
"അഴിയുക" സംഭവിക്കുമ്പോൾ ഇതിനെ വിളിക്കുന്നു. താഴെയുള്ള "അഴിയുക" ഗോച്ച കാണുക.

ഇത് നശിപ്പിക്കുക
ഒരു ടൈഡ് ഹാഷ് സ്കോപ്പിന് പുറത്ത് പോകുമ്പോൾ ഈ രീതി ട്രിഗർ ചെയ്യപ്പെടുന്നു. നിങ്ങൾ ചെയ്യരുത്
നിങ്ങൾ ഡീബഗ്ഗിംഗ് ചേർക്കാൻ ശ്രമിക്കുന്നില്ലെങ്കിൽ അല്ലെങ്കിൽ വൃത്തിയാക്കാൻ സഹായകരമായ അവസ്ഥ ഇല്ലെങ്കിൽ ഇത് ശരിക്കും ആവശ്യമാണ്
മുകളിലേക്ക്. വളരെ ലളിതമായ ഒരു ഫംഗ്‌ഷൻ ഇതാ:

ഉപ നശിപ്പിക്കുക {
$DEBUG ആണെങ്കിൽ കരിമീൻ &whowasi;
}

പോലുള്ള പ്രവർത്തനങ്ങൾ ശ്രദ്ധിക്കുക കീകൾ() ഒപ്പം മൂല്യങ്ങൾ () വലിയവയിൽ ഉപയോഗിക്കുമ്പോൾ വലിയ ലിസ്റ്റുകൾ തിരികെ നൽകിയേക്കാം
DBM ഫയലുകൾ പോലെയുള്ള വസ്തുക്കൾ. നിങ്ങൾക്ക് ഉപയോഗിക്കാൻ താൽപ്പര്യപ്പെട്ടേക്കാം ഓരോ () അത്തരത്തിൽ ആവർത്തിക്കാനുള്ള പ്രവർത്തനം.
ഉദാഹരണം:

# ഹിസ്റ്ററി ഫയൽ ഓഫ്‌സെറ്റുകൾ പ്രിന്റ് ഔട്ട് ചെയ്യുക
NDBM_File ഉപയോഗിക്കുക;
ടൈ (%HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
അതേസമയം (($കീ, $val) = ഓരോ %HIST) {
പ്രിന്റ് $കീ, ' = ', അൺപാക്ക്('L',$val), "\n";
}
അഴിക്കുക(%HIST);

കെട്ടുന്നു ഫയൽഹാൻഡിലുകൾ
ഇതാണ് ഇപ്പോൾ ഭാഗികമായി നടപ്പാക്കിയിരിക്കുന്നത്.

ഒരു ടൈഡ് ഫയൽഹാൻഡിൽ നടപ്പിലാക്കുന്ന ഒരു ക്ലാസ് ഇനിപ്പറയുന്ന രീതികൾ നിർവചിക്കേണ്ടതാണ്: TIEHANDLE, at
PRINT, PRINTF, WRITE, READLINE, GETC, വായിക്കുക, ഒരുപക്ഷേ ക്ലോസ്, UNTIE എന്നിവയിൽ ഒന്ന്
നശിപ്പിക്കുക. ക്ലാസിന് ഇനിപ്പറയുന്നവയും നൽകാൻ കഴിയും: BINMODE, OPEN, EOF, FILENO, അന്വേഷിക്കുക, പറയുക - എങ്കിൽ
അനുബന്ധ perl ഓപ്പറേറ്റർമാർ ഹാൻഡിൽ ഉപയോഗിക്കുന്നു.

STDERR ബന്ധിപ്പിക്കുമ്പോൾ, മുന്നറിയിപ്പുകളും പിശക് സന്ദേശങ്ങളും നൽകുന്നതിന് അതിന്റെ പ്രിന്റ് രീതി വിളിക്കപ്പെടും.
കോളിനിടയിൽ ഈ സവിശേഷത താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു, അതായത് നിങ്ങൾക്ക് "warn()" ഉപയോഗിക്കാം
ഒരു ആവർത്തന ലൂപ്പ് ആരംഭിക്കാതെ തന്നെ പ്രിന്റിനുള്ളിൽ. "__WARN__", "__DIE__" എന്നിവ പോലെ
ഹാൻഡ്‌ലറുകൾ, പാഴ്‌സർ പിശകുകൾ റിപ്പോർട്ടുചെയ്യാൻ STDERR-ന്റെ പ്രിന്റ് രീതി വിളിച്ചേക്കാം, അതിനാൽ മുന്നറിയിപ്പ് നൽകുന്നു
perlvar apply എന്നതിൽ "%SIG" എന്നതിന് കീഴിൽ സൂചിപ്പിച്ചിരിക്കുന്നു.

ഔട്ട്പുട്ട് ചെയ്യുന്ന മറ്റേതെങ്കിലും പ്രോഗ്രാമിൽ perl ഉൾച്ചേർക്കുമ്പോൾ ഇതെല്ലാം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
STDOUT-ലേയ്ക്കും STDERR-ലേയ്ക്കും ചില പ്രത്യേക രീതിയിൽ റീഡയറക്‌ട് ചെയ്യേണ്ടി വന്നേക്കാം. എൻവിയും ദിയും കാണുക
ഉദാഹരണങ്ങൾക്കായി അപ്പാച്ചെ മൊഡ്യൂൾ.

ഒരു ഹാൻഡിൽ കെട്ടുമ്പോൾ, "ടൈ" ചെയ്യുന്നതിനുള്ള ആദ്യ വാദം ഒരു നക്ഷത്രചിഹ്നത്തിൽ ആരംഭിക്കണം. അങ്ങനെയാണെങ്കില്
നിങ്ങൾ STDOUT കെട്ടുകയാണ്, *STDOUT ഉപയോഗിക്കുക. നിങ്ങൾ ഇത് ഒരു സ്കെയിലർ വേരിയബിളിലേക്ക് നൽകിയിട്ടുണ്ടെങ്കിൽ, പറയുക
$ഹാൻഡിൽ, *$ഹാൻഡിൽ ഉപയോഗിക്കുക. "ടൈ $ഹാൻഡിൽ", സ്കെയിലർ വേരിയബിളായ $ഹാൻഡിൽ ബന്ധിപ്പിക്കുന്നു, ഹാൻഡിലല്ല
അതിനുള്ളിൽ.

ഞങ്ങളുടെ ഉദാഹരണത്തിൽ ഞങ്ങൾ ഒരു ശബ്ദ ഹാൻഡിൽ സൃഷ്ടിക്കാൻ പോകുന്നു.

പാക്കേജ് ഷൗട്ട്;

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

സബ് ടൈഹാൻഡിൽ { പ്രിന്റ് " \n"; എന്റെ $i; അനുഗ്രഹിക്കൂ \$i, shift }

ഇത് എഴുതുക, പട്ടിക
"syswrite" ഫംഗ്‌ഷൻ വഴി ഹാൻഡിൽ എഴുതുമ്പോൾ ഈ രീതിയെ വിളിക്കും.

ഉപ എഴുതുക {
$r = shift;
my($buf,$len,$offset) = @_;
"എഴുതുക, \$buf=$buf, \$len=$len, \$offset=$offset";
}

ഇത് പ്രിന്റ് ചെയ്യുക, ലിസ്റ്റ്
ഓരോ തവണയും കെട്ടിയ ഹാൻഡിൽ പ്രിന്റ് ചെയ്യുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും
"print()" അല്ലെങ്കിൽ "say()" ഫംഗ്ഷനുകൾ. അതിന്റെ സെൽഫ് റഫറൻസിനപ്പുറം അത് ലിസ്റ്റ് പ്രതീക്ഷിക്കുന്നു
അത് പ്രിന്റ് ഫംഗ്ഷനിലേക്ക് കൈമാറി.

സബ് പ്രിന്റ് {$r = shift; $$r++; പ്രിന്റ് ജോയിൻ($,,മാപ്പ്(uc($_),@_)),$\}

"say()" $\ ഒഴികെയുള്ള "print()" പോലെ പ്രവർത്തിക്കുന്നു "\n" എന്നതിലേക്ക് പ്രാദേശികവൽക്കരിക്കപ്പെടും അതിനാൽ നിങ്ങൾ ചെയ്യേണ്ടത് ആവശ്യമാണ്
"PRINT()" എന്നതിൽ "പറയുക()" കൈകാര്യം ചെയ്യാൻ പ്രത്യേകിച്ചൊന്നുമില്ല.

ഇത് പ്രിന്റ് ചെയ്യുക, ലിസ്റ്റ്
ഓരോ തവണയും കെട്ടിയ ഹാൻഡിൽ പ്രിന്റ് ചെയ്യുമ്പോൾ ഈ രീതി പ്രവർത്തനക്ഷമമാകും
"printf()" ഫംഗ്‌ഷൻ. അതിന്റെ സെൽഫ് റഫറൻസിനപ്പുറം അത് ഫോർമാറ്റും ലിസ്റ്റും പ്രതീക്ഷിക്കുന്നു
അത് printf ഫംഗ്‌ഷനിലേക്ക് കൈമാറി.

ഉപ PRINTF {
ഷിഫ്റ്റ്;
എന്റെ $fmt = shift;
പ്രിന്റ് സ്പ്രിന്റ്ഫ് ($fmt, @_);
}

ഇത് വായിക്കുക, പട്ടിക
"വായിക്കുക" അല്ലെങ്കിൽ "sysread" വഴി ഹാൻഡിൽ വായിക്കുമ്പോൾ ഈ രീതിയെ വിളിക്കും
പ്രവർത്തനങ്ങൾ.

ഉപ വായിക്കുക {
എന്റെ $self = shift;
എന്റെ $bufref = \$_[0];
my(undef,$len,$offset) = @_;
പ്രിന്റ് "റീഡ് വിളിച്ചു, \$buf=$bufref, \$len=$len, \$offset=$offset";
# $$bufref-ലേക്ക് ചേർക്കുക, വായിച്ച അക്ഷരങ്ങളുടെ എണ്ണമായി $len സജ്ജമാക്കുക
$len;
}

ഇത് വായിക്കുക
"" വഴി ഹാൻഡിൽ വായിക്കുമ്പോൾ ഈ രീതിയെ വിളിക്കുന്നു "അല്ലെങ്കിൽ "റെഡ്‌ലൈൻ ഹാൻഡിൽ".

"റെഡ്‌ലൈൻ" അനുസരിച്ച്, സ്കെയിലർ സന്ദർഭത്തിൽ അത് അടുത്ത വരി നൽകണം, അല്ലെങ്കിൽ ഇല്ല എന്നതിന് "undef"
കൂടുതൽ ഡാറ്റ. ലിസ്റ്റ് സന്ദർഭത്തിൽ, ബാക്കിയുള്ള എല്ലാ വരികളും അല്ലെങ്കിൽ ഒരു ശൂന്യമായ ലിസ്റ്റ് നൽകണം
കൂടുതൽ ഡാറ്റ ഇല്ല. തിരികെ നൽകിയ സ്ട്രിംഗുകളിൽ ഇൻപുട്ട് റെക്കോർഡ് സെപ്പറേറ്റർ $/ ഉൾപ്പെടുത്തണം (കാണുക
perlvar), അത് "undef" (അതായത് "സ്ലർപ്പ്" മോഡ്) അല്ലാത്തപക്ഷം.

സബ് റീഡ്‌ലൈൻ {
എന്റെ $r = shift;
എങ്കിൽ (wantarray) {
മടങ്ങുക ("എല്ലാം ബാക്കി\n",
"വരികൾ അപ്പ്\n",
"ഇഓഫ്\n");
} else {
തിരികെ "റീഡ്‌ലൈൻ വിളിച്ചു" . ++$$r . "തവണ\n";
}
}

ഇത് നേടുക
"getc" ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ ഈ രീതി വിളിക്കപ്പെടും.

ഉപ GETC { പ്രിന്റ് "GETC ചെയ്യരുത്, പേൾ നേടുക"; തിരികെ "a"; }

EOF ഇത്
"eof" ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ ഈ രീതി വിളിക്കപ്പെടും.

Perl 5.12 മുതൽ, ഒരു അധിക പൂർണ്ണസംഖ്യ പാരാമീറ്റർ കടന്നുപോകും. ഇത് ഇങ്ങനെയായിരിക്കും
പാരാമീറ്റർ ഇല്ലാതെ "eof" എന്ന് വിളിക്കുകയാണെങ്കിൽ പൂജ്യം; 1 "eof" എന്നതിന് ഒരു ഫയൽ ഹാൻഡിൽ നൽകിയിട്ടുണ്ടെങ്കിൽ a
പാരാമീറ്റർ, ഉദാ "eof(FH)"; കെട്ടിയ ഫയൽ ഹാൻഡിൽ ആയ പ്രത്യേക സാഹചര്യത്തിൽ 2 ഉം
"ARGV" ഉം "eof" ഉം ഒരു ശൂന്യമായ പാരാമീറ്റർ പട്ടികയിൽ വിളിക്കുന്നു, ഉദാ "eof()".

ഉപ EOF {നീളം അല്ല $stringbuf}

ഇത് അടയ്ക്കുക
"ക്ലോസ്" ഫംഗ്ഷൻ വഴി ഹാൻഡിൽ അടയ്ക്കുമ്പോൾ ഈ രീതി വിളിക്കപ്പെടും.

സബ് ക്ലോസ് { പ്രിന്റ് "ക്ലോസ് വിളിച്ചു.\n" }

ഇത് UNTIE ചെയ്യുക
മറ്റ് തരത്തിലുള്ള ബന്ധങ്ങൾ പോലെ, ഈ രീതി "അഴിവ്" സംഭവിക്കുമ്പോൾ വിളിക്കപ്പെടും. അത്
ഇത് സംഭവിക്കുമ്പോൾ "യാന്ത്രികമായി അടയ്ക്കുക" എന്നത് ഉചിതമായിരിക്കും. താഴെയുള്ള "അഴിയുക" ഗോച്ച കാണുക.

ഇത് നശിപ്പിക്കുക
മറ്റ് തരത്തിലുള്ള ബന്ധങ്ങൾ പോലെ, കെട്ടഴിഞ്ഞ ഹാൻഡിൽ ആയിരിക്കുമ്പോൾ ഈ രീതിയെ വിളിക്കും
നശിപ്പിക്കപ്പെടാൻ പോകുന്നു. ഡീബഗ്ഗിംഗിനും ഒരുപക്ഷേ വൃത്തിയാക്കുന്നതിനും ഇത് ഉപയോഗപ്രദമാണ്.

ഉപ നശിപ്പിക്കുക { പ്രിന്റ് " \n"}

ഞങ്ങളുടെ ചെറിയ ഉദാഹരണം എങ്ങനെ ഉപയോഗിക്കാമെന്നത് ഇതാ:

ടൈ (*FOO,'Shout');
പ്രിന്റ് FOO "ഹലോ\n";
$a = 4; $b = 6;
പ്രിന്റ് FOO $a, " പ്ലസ് ", $b, " സമം ", $a + $b, "\n";
അച്ചടിക്കുക ;

UNTIE ഈ
നിങ്ങൾക്ക് എല്ലാ ടൈ തരങ്ങൾക്കും ഒരു UNTIE രീതി നിർവചിക്കാം അഴിക്കുക(). കാണുക "ദി
താഴെ "കെട്ടഴിക്കുക" Gotcha".

ദി "കെട്ടഴിക്കുക" ഗോച്ച
രണ്ടിൽ നിന്നും തിരികെ ലഭിച്ച ഒബ്‌ജക്‌റ്റ് ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ടൈ() or കെട്ടി (), എങ്കിൽ
ടൈയുടെ ടാർഗെറ്റ് ക്ലാസ് ഒരു ഡിസ്ട്രക്റ്ററിനെ നിർവചിക്കുന്നു, നിങ്ങൾക്ക് ഒരു സൂക്ഷ്മതയുണ്ട് ആവശമാകുന്നു സൂക്ഷിക്കുക.

സജ്ജീകരണമെന്ന നിലയിൽ, ഒരു ടൈയുടെ ഉദാഹരണം പരിഗണിക്കുക. അത് ഉപയോഗിക്കുന്നത് മാത്രമാണ്
സ്കെയിലറിലേക്ക് അസൈൻ ചെയ്‌തിരിക്കുന്ന മൂല്യങ്ങളുടെ ഒരു ലോഗ് സൂക്ഷിക്കുന്നതിനുള്ള ഒരു ഫയൽ.

പാക്കേജ് ഓർക്കുക;

കർശനമായി ഉപയോഗിക്കുക;
മുന്നറിയിപ്പുകൾ ഉപയോഗിക്കുക;
IO :: ഫയൽ ഉപയോഗിക്കുക;

സബ് ടൈസ്‌കലാർ {
എന്റെ $ ക്ലാസ് = ഷിഫ്റ്റ്;
എന്റെ $ഫയലിന്റെ പേര് = shift;
my $handle = IO::File->new( "> $filname" )
അല്ലെങ്കിൽ മരിക്കുക "$filname: $!\n തുറക്കാൻ കഴിയില്ല";

പ്രിന്റ് $ഹാൻഡിൽ "ദി സ്റ്റാർട്ട്\n";
അനുഗ്രഹിക്കൂ {FH => $ഹാൻഡിൽ, മൂല്യം => 0}, $ക്ലാസ്;
}

സബ് ഫെച്ച് {
എന്റെ $self = shift;
$self->{value} തിരികെ നൽകുക;
}

ഉപ സ്റ്റോർ {
എന്റെ $self = shift;
എന്റെ $ മൂല്യം = ഷിഫ്റ്റ്;
എന്റെ $ഹാൻഡിൽ = $self->{FH};
പ്രിന്റ് $ഹാൻഡിൽ "$value\n";
$self->{value} = $value;
}

ഉപ നശിപ്പിക്കുക {
എന്റെ $self = shift;
എന്റെ $ഹാൻഡിൽ = $self->{FH};
പ്രിന്റ് $ഹാൻഡിൽ "The End\n";
$ ഹാൻഡിൽ അടയ്ക്കുക;
}

1;

ഈ ടൈ ഉപയോഗപ്പെടുത്തുന്ന ഒരു ഉദാഹരണം ഇതാ:

കർശനമായി ഉപയോഗിക്കുക;
ഓർമ്മിക്കുക ഉപയോഗിക്കുക;

എന്റെ $ഫ്രെഡ്;
ടൈ $ഫ്രെഡ്, 'ഓർമ്മിക്കുക', 'myfile.txt';
$ഫ്രെഡ് = 1;
$ഫ്രെഡ് = 4;
$ഫ്രെഡ് = 5;
$ഫ്രെഡ് അഴിക്കുക;
സിസ്റ്റം "cat myfile.txt";

ഇത് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ലഭിക്കുന്ന ഔട്ട്പുട്ട് ഇതാണ്:

തുടക്കം
1
4
5
അവസാനം

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

ഉപ അഭിപ്രായം {
എന്റെ $self = shift;
എന്റെ $ ടെക്സ്റ്റ് = shift;
എന്റെ $ഹാൻഡിൽ = $self->{FH};
പ്രിന്റ് $ഹാൻഡിൽ $ടെക്സ്റ്റ്, "\n";
}

"അഭിപ്രായം" രീതി ഉപയോഗിക്കുന്നതിന് പരിഷ്കരിച്ച മുമ്പത്തെ ഉദാഹരണം ഇതാ (ഇത് ആവശ്യമാണ്
കെട്ടിയ വസ്തു):

കർശനമായി ഉപയോഗിക്കുക;
ഓർമ്മിക്കുക ഉപയോഗിക്കുക;

എന്റെ ($ഫ്രെഡ്, $x);
$x = ടൈ $ഫ്രെഡ്, 'ഓർക്കുക', 'myfile.txt';
$ഫ്രെഡ് = 1;
$ഫ്രെഡ് = 4;
അഭിപ്രായം $x "മാറുന്നു...";
$ഫ്രെഡ് = 5;
$ഫ്രെഡ് അഴിക്കുക;
സിസ്റ്റം "cat myfile.txt";

ഈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ ഔട്ട്പുട്ട് ഇല്ല. എന്തുകൊണ്ടെന്ന് ഇതാ:

ഒരു വേരിയബിൾ കെട്ടുമ്പോൾ, അത് റിട്ടേൺ മൂല്യമായ ഒബ്‌ജക്‌റ്റുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു
TIESCALAR, TIERRAY, അല്ലെങ്കിൽ TIEHASH ഫംഗ്‌ഷൻ. ഈ വസ്തുവിന് സാധാരണയായി ഒരു റഫറൻസ് മാത്രമേയുള്ളൂ,
അതായത്, ടൈഡ് വേരിയബിളിൽ നിന്നുള്ള അവ്യക്തമായ റഫറൻസ്. എപ്പോൾ അഴിക്കുക() വിളിക്കുന്നു, എന്ന്
റഫറൻസ് നശിപ്പിക്കപ്പെട്ടു. തുടർന്ന്, മുകളിലെ ആദ്യ ഉദാഹരണത്തിലെന്നപോലെ, വസ്തുവിന്റെ ഡിസ്ട്രക്റ്റർ
(DESTROY) എന്ന് വിളിക്കുന്നു, സാധുതയുള്ള റഫറൻസുകളില്ലാത്ത ഒബ്‌ജക്റ്റുകൾക്ക് ഇത് സാധാരണമാണ്; ഒപ്പം
അങ്ങനെ ഫയൽ അടച്ചു.

എന്നിരുന്നാലും, രണ്ടാമത്തെ ഉദാഹരണത്തിൽ, കെട്ടിയിരിക്കുന്ന വസ്തുവിനെക്കുറിച്ചുള്ള മറ്റൊരു റഫറൻസ് ഞങ്ങൾ $x-ൽ സംഭരിച്ചിട്ടുണ്ട്.
അതിനർത്ഥം എപ്പോൾ എന്നാണ് അഴിക്കുക() വിളിക്കപ്പെടുന്നു എന്നതിന് സാധുതയുള്ള ഒരു റഫറൻസ് ഇനിയും ഉണ്ടാകും
ഒബ്ജക്റ്റ് നിലവിലുണ്ട്, അതിനാൽ ആ സമയത്ത് ഡിസ്ട്രക്റ്റർ വിളിക്കപ്പെടുന്നില്ല, അതിനാൽ ഫയൽ അങ്ങനെയാണ്
അടച്ചിട്ടില്ല. ഫയൽ ബഫറുകൾ ഇല്ലാത്തതാണ് ഔട്ട്പുട്ട് ഇല്ലാത്തതിന്റെ കാരണം
ഡിസ്കിലേക്ക് ഫ്ലഷ് ചെയ്തു.

പ്രശ്നം എന്താണെന്ന് ഇപ്പോൾ നിങ്ങൾക്കറിയാം, അത് ഒഴിവാക്കാൻ നിങ്ങൾക്ക് എന്തുചെയ്യാൻ കഴിയും? മുമ്പ്
ഓപ്ഷണൽ UNTIE രീതിയുടെ ആമുഖം പഴയ നല്ല "-w" ഫ്ലാഗ് മാത്രമായിരുന്നു. ഏത്
നിങ്ങൾ വിളിക്കുന്ന ഏതെങ്കിലും സന്ദർഭങ്ങൾ കണ്ടെത്തും അഴിക്കുക() എന്നതിന് ഇപ്പോഴും സാധുവായ പരാമർശങ്ങളുണ്ട്
കെട്ടിയ വസ്തു. ഇതിന് മുകളിലുള്ള രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് മുകളിലാണെങ്കിൽ "ഉപയോഗ മുന്നറിയിപ്പ് 'അഴിക്കുക'" അല്ലെങ്കിൽ ആയിരുന്നു
"-w" ഫ്ലാഗ് ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക, പേൾ ഈ മുന്നറിയിപ്പ് സന്ദേശം അച്ചടിക്കുന്നു:

1 ആന്തരിക റഫറൻസുകൾ നിലവിലിരിക്കെ അഴിച്ചുമാറ്റാൻ ശ്രമിച്ചു

സ്ക്രിപ്റ്റ് ശരിയായി പ്രവർത്തിക്കാനും മുന്നറിയിപ്പ് നിശബ്ദമാക്കാനും സാധുതയൊന്നുമില്ലെന്ന് ഉറപ്പാക്കുക
ബന്ധിച്ച വസ്തുവിനെക്കുറിച്ചുള്ള പരാമർശങ്ങൾ മുമ്പ് അഴിക്കുക() വിളിച്ചു:

undef $x;
$ഫ്രെഡ് അഴിക്കുക;

ഇപ്പോൾ UNTIE ഉള്ളതിനാൽ ക്ലാസ് ഡിസൈനർക്ക് ക്ലാസ് പ്രവർത്തനത്തിന്റെ ഏതൊക്കെ ഭാഗങ്ങൾ തീരുമാനിക്കാം
യഥാർത്ഥത്തിൽ "കെട്ടഴിച്ചുവിടുക" എന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, അത് നശിപ്പിക്കപ്പെടുന്ന വസ്തുവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. എന്ത് ഉണ്ടാക്കുന്നു
തന്നിരിക്കുന്ന ക്ലാസ്സിന്റെ അർത്ഥം ആന്തരിക റഫറൻസുകൾ അങ്ങനെ സൂക്ഷിക്കുന്നുണ്ടോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
നോൺ-ടൈ-അനുബന്ധ രീതികൾ ഒബ്ജക്റ്റിൽ വിളിക്കാം. എന്നാൽ മിക്ക കേസുകളിലും അത് ഒരുപക്ഷേ ഉണ്ടാക്കുന്നു
DESTROY-ൽ ഉണ്ടാകുമായിരുന്ന പ്രവർത്തനക്ഷമത UNTIE രീതിയിലേക്ക് നീക്കാൻ അർത്ഥമുണ്ട്.

UNTIE രീതി നിലവിലുണ്ടെങ്കിൽ, മുകളിലുള്ള മുന്നറിയിപ്പ് സംഭവിക്കില്ല. പകരം UNTIE രീതി
"അധിക" റഫറൻസുകളുടെ എണ്ണം കടന്നുപോയി, ഉചിതമെങ്കിൽ അതിന്റേതായ മുന്നറിയിപ്പ് നൽകാം.
ഉദാ: നോ UNTIE കേസ് ആവർത്തിക്കാൻ ഈ രീതി ഉപയോഗിക്കാം:

ഉപ UNTIE
{
എന്റെ ($obj,$count) = @_;
$count ആണെങ്കിൽ "$count ആന്തരിക റഫറൻസുകൾ നിലവിലിരിക്കെ അഴിച്ചുമാറ്റാൻ ശ്രമിച്ചു";
}

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perltie ഓൺലൈനായി ഉപയോഗിക്കുക