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

പട്ടിക:

NAME

perlfaq4 - ഡാറ്റ കൃത്രിമത്വം

പതിപ്പ്

പതിപ്പ് 5.021009

വിവരണം

പതിവ് ചോദ്യങ്ങളുടെ ഈ വിഭാഗം നമ്പറുകൾ, തീയതികൾ, സ്ട്രിംഗുകൾ എന്നിവ കൈകാര്യം ചെയ്യുന്നതുമായി ബന്ധപ്പെട്ട ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നു.
അറേകൾ, ഹാഷുകൾ, വിവിധ ഡാറ്റ പ്രശ്നങ്ങൾ.

ഡാറ്റ: സംഖ്യാപുസ്തകം

എന്തുകൊണ്ട് am I ലഭിക്കുന്നു നീളമുള്ള ദശാംശങ്ങൾ (ഉദാ. 19.9499999999999) പകരം of The നമ്പറുകൾ I വേണം be
ലഭിക്കുന്നു (ഉദാ. 19.95)?
ദൈർഘ്യമേറിയ വിശദീകരണത്തിന്, ഡേവിഡ് ഗോൾഡ്ബെർഗിന്റെ "ഓരോ കമ്പ്യൂട്ടർ സയന്റിസ്റ്റും അറിഞ്ഞിരിക്കേണ്ടത്" കാണുക
ഫ്ലോട്ടിംഗ് പോയിന്റ് അരിത്മെറ്റിക്കിനെക്കുറിച്ച്"
(<http://web.cse.msu.edu/~cse320/Documents/FloatingPoint.pdf>).

ആന്തരികമായി, നിങ്ങളുടെ കമ്പ്യൂട്ടർ ബൈനറിയിൽ ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകളെ പ്രതിനിധീകരിക്കുന്നു. ഡിജിറ്റൽ (ഇതുപോലെ
രണ്ടിന്റെ ശക്തി) കമ്പ്യൂട്ടറുകൾക്ക് എല്ലാ നമ്പറുകളും കൃത്യമായി സംഭരിക്കാൻ കഴിയില്ല. ചില യഥാർത്ഥ സംഖ്യകൾ നഷ്ടപ്പെടുന്നു
പ്രക്രിയയിൽ കൃത്യത. കമ്പ്യൂട്ടറുകൾ നമ്പറുകൾ എങ്ങനെ സംഭരിക്കുന്നു എന്നതിലെ പ്രശ്നമാണിത്
പേൾ മാത്രമല്ല, എല്ലാ കമ്പ്യൂട്ടർ ഭാഷകളും.

പെർൽനമ്പർ സംഖ്യാ പ്രതിനിധാനങ്ങളുടെയും പരിവർത്തനങ്ങളുടെയും ഗുരുതരമായ വിശദാംശങ്ങൾ കാണിക്കുന്നു.

നിങ്ങളുടെ സംഖ്യകളിലെ ദശാംശ സ്ഥാനങ്ങളുടെ എണ്ണം പരിമിതപ്പെടുത്തുന്നതിന്, നിങ്ങൾക്ക് "printf" അല്ലെങ്കിൽ ഉപയോഗിക്കാം
"sprintf" ഫംഗ്ഷൻ. കൂടുതൽ വിവരങ്ങൾക്ക് പെർലോപ്പിലെ "ഫ്ലോട്ടിംഗ് പോയിന്റ് അരിത്മെറ്റിക്" കാണുക.

printf "%.2f", 10/3;

എന്റെ $നമ്പർ = സ്പ്രിന്റ്ഫ് "%.2f", 10/3;

എന്തുകൊണ്ട് is int() തകർന്നോ?
നിങ്ങളുടെ "int()" മിക്കവാറും നന്നായി പ്രവർത്തിക്കുന്നുണ്ട്. അക്കങ്ങൾ അത്രയൊന്നും അല്ല
നിങ്ങൾ ചിന്തിക്കുക.

ആദ്യം, "എന്തുകൊണ്ടാണ് എനിക്ക് ദൈർഘ്യമേറിയ ദശാംശങ്ങൾ ലഭിക്കുന്നത് (ഉദാ, 19.9499999999999) എന്നതിന്റെ ഉത്തരം കാണുക
എനിക്ക് ലഭിക്കേണ്ട സംഖ്യകൾ (ഉദാ, 19.95)?".

ഉദാഹരണത്തിന്, ഇത്

പ്രിന്റ് int(0.6/0.2-2), "\n";

മിക്ക കമ്പ്യൂട്ടറുകളിലും 0, 1 അല്ല, 0.6, 0.2 എന്നിങ്ങനെയുള്ള ലളിതമായ സംഖ്യകൾ പോലും അച്ചടിക്കും.
ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ ഉപയോഗിച്ച് കൃത്യമായി അവതരിപ്പിക്കാൻ കഴിയില്ല. മുകളിൽ പറഞ്ഞതിൽ നിങ്ങൾ എന്താണ് ചിന്തിക്കുന്നത്
'മൂന്ന്' എന്നത് ശരിക്കും 2.9999999999999995559 പോലെയാണ്.

എന്തുകൊണ്ട് അല്ല my ഒക്ടൽ ഡാറ്റ വ്യാഖ്യാനിച്ചു ശരിയായി?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾ ഒരു സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുന്നുണ്ടാകാം, അത് പേൾ ഒരു ആയി മാത്രം പരിവർത്തനം ചെയ്യുന്നു
ദശാംശ സംഖ്യ. Perl ഒരു സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ, അത് മുൻനിര സ്‌പെയ്‌സുകളെ അവഗണിക്കുന്നു
പൂജ്യങ്ങൾ, തുടർന്ന് ബാക്കിയുള്ള അക്കങ്ങൾ അടിസ്ഥാനം 10-ലാണെന്ന് അനുമാനിക്കുന്നു:

എന്റെ $string = '0644';

$string + 0 പ്രിന്റ് ചെയ്യുക; # പ്രിന്റുകൾ 644

$ string + 44 പ്രിന്റ് ചെയ്യുക; # പ്രിന്റുകൾ 688, തീർച്ചയായും ഒക്ടൽ അല്ല!

ഈ പ്രശ്നം സാധാരണയായി Unix എന്ന അതേ പേരുള്ള Perl ബിൽറ്റ്-ഇന്നുകളിൽ ഒന്നാണ്
കമാൻഡ് ലൈനിലെ ആർഗ്യുമെന്റുകളായി ഒക്ടൽ നമ്പറുകൾ ഉപയോഗിക്കുന്ന കമാൻഡ്. ഈ ഉദാഹരണത്തിൽ, "chmod"
കമാൻഡ് ലൈനിൽ അതിന്റെ ആദ്യത്തെ ആർഗ്യുമെന്റ് ഒക്ടൽ ആണെന്ന് അറിയാം, കാരണം അതാണ് ചെയ്യുന്നത്:

%prompt> chmod 644 ഫയൽ

നിങ്ങൾക്ക് Perl-ൽ ഒരേ അക്ഷര അക്കങ്ങൾ (644) ഉപയോഗിക്കണമെങ്കിൽ, ചികിത്സിക്കാൻ നിങ്ങൾ Perl-നോട് പറയണം.
അക്കങ്ങൾ 0 ഉപയോഗിച്ച് മുൻ‌കൂട്ടി ചേർത്തോ അല്ലെങ്കിൽ "oct" ഉപയോഗിച്ചോ അവയെ ഒക്ടൽ നമ്പറുകളായി:

chmod( 0644, $filname ); # വലത്, മുന്നിൽ പൂജ്യം ഉണ്ട്
chmod( ഒക്ടോബർ(644), $ഫയലിന്റെ പേര് ); #ഉം ശരിയാണ്

പേൾ കരുതുന്ന ഒന്നിൽ നിന്ന് നിങ്ങളുടെ നമ്പറുകൾ എടുക്കുമ്പോഴാണ് പ്രശ്നം വരുന്നത്
@ARGV-ലെ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് പോലുള്ള സ്ട്രിംഗ്:

chmod( $ARGV[0], $filname ); # തെറ്റ്, "0644" ആണെങ്കിലും

chmod( oct($ARGV[0]), $filname ); # ശരിയാണ്, സ്ട്രിംഗിനെ അഷ്ടമായി കണക്കാക്കുക

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

printf "0%o %d", $number, $number;

പ്രവർത്തിക്കുന്നുണ്ട് പേൾ ഉണ്ട് a റൗണ്ട് () പ്രവർത്തനം? എന്ത് കുറിച്ച് സീൽ() ഒപ്പം ഫ്ലോർ ()? ട്രിഗ് പ്രവർത്തനങ്ങൾ?
"int()" കേവലം 0 ലേക്ക് ചുരുക്കുന്നു എന്ന് ഓർക്കുക. ഒരു നിശ്ചിത സംഖ്യയിലേക്ക് റൗണ്ട് ചെയ്യുന്നതിന്
അക്കങ്ങൾ, "sprintf()" അല്ലെങ്കിൽ "printf()" ആണ് സാധാരണയായി ഏറ്റവും എളുപ്പമുള്ള റൂട്ട്.

printf("%.3f", 3.1415926535); # പ്രിന്റുകൾ 3.142

POSIX മൊഡ്യൂൾ (സാധാരണ പേൾ ​​വിതരണത്തിന്റെ ഭാഗം) "ceil()", "floor()", എന്നിവ നടപ്പിലാക്കുന്നു.
കൂടാതെ മറ്റ് നിരവധി ഗണിത, ത്രികോണമിതി ഫംഗ്ഷനുകളും.

POSIX ഉപയോഗിക്കുക;
എന്റെ $ സീൽ = സീൽ(3.5); # 4
എന്റെ $ഫ്ലോർ = ഫ്ലോർ(3.5); # 3

5.000 മുതൽ 5.003 വരെ പെർലുകളിൽ, മത്ത്:: കോംപ്ലക്സ് മൊഡ്യൂളിൽ ത്രികോണമിതി നടത്തി. 5.004 ഉപയോഗിച്ച്,
Math::Trig മൊഡ്യൂൾ (സാധാരണ പേൾ ​​വിതരണത്തിന്റെ ഭാഗം) നടപ്പിലാക്കുന്നു
ത്രികോണമിതി പ്രവർത്തനങ്ങൾ. ആന്തരികമായി ഇത് Math :: Complex മൊഡ്യൂളും ചില പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നു
യഥാർത്ഥ അക്ഷത്തിൽ നിന്ന് സങ്കീർണ്ണമായ തലത്തിലേക്ക് പൊട്ടിത്തെറിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് വിപരീത സൈൻ
2.

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

എന്തുകൊണ്ടെന്ന് കാണാൻ, ഹാഫ്-വേ-പോയിന്റ് ആൾട്ടർനേഷനിൽ നിങ്ങൾക്ക് ഇപ്പോഴും എങ്ങനെ പ്രശ്‌നമുണ്ടാകുമെന്ന് ശ്രദ്ധിക്കുക:

(എന്റെ $i = 0; $i < 1.01; $i += 0.05) {printf "%.1f ",$i}

0.0 0.1 0.1 0.2 0.2 0.2 0.3 0.3 0.4 0.4 0.5 0.5
0.8 0.8 0.9 XIX XIX 0.9

പേളിനെ കുറ്റപ്പെടുത്തരുത്. നമ്മൾ ഇത് ചെയ്യണം എന്ന് C. IEEE-ൽ പറയുന്നത് പോലെ തന്നെ. പേൾ നമ്പറുകൾ ആരുടെ
കേവല മൂല്യങ്ങൾ 2**31-ന് താഴെയുള്ള പൂർണ്ണസംഖ്യകളാണ് (32-ബിറ്റ് മെഷീനുകളിൽ)
ഗണിത പൂർണ്ണസംഖ്യകൾ. മറ്റ് നമ്പറുകൾക്ക് ഉറപ്പില്ല.

എങ്ങനെ do I മാറ്റുക തമ്മിലുള്ള സംഖ്യ പ്രാതിനിധ്യങ്ങൾ/അടിസ്ഥാനങ്ങൾ/റാഡിക്സുകൾ?
എല്ലായ്‌പ്പോഴും എന്നപോലെ പേളിന് ഒന്നിലധികം മാർഗങ്ങളുണ്ട്. ചില ഉദാഹരണങ്ങൾ താഴെ കൊടുക്കുന്നു
സംഖ്യാ പ്രാതിനിധ്യങ്ങൾക്കിടയിൽ പൊതുവായ പരിവർത്തനം നടത്തുന്നതിനുള്ള സമീപനങ്ങൾ. ഇത് ഉദ്ദേശിച്ചിട്ടുള്ളതാണ്
സമഗ്രമായതിനേക്കാൾ പ്രാതിനിധ്യം.

പിന്നീട് perlfaq4-ൽ ചില ഉദാഹരണങ്ങൾ CPAN-ൽ നിന്നുള്ള Bit::Vector മൊഡ്യൂൾ ഉപയോഗിക്കുന്നു. കാരണം
നിങ്ങൾക്ക് ബിറ്റ്:: വെക്റ്റർ തിരഞ്ഞെടുക്കാം, അത് പെർൾ ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകളിൽ പ്രവർത്തിക്കുന്നു
ചില പ്രവർത്തനങ്ങളിലെ വേഗതയ്‌ക്കായി ഒപ്റ്റിമൈസ് ചെയ്‌തിരിക്കുന്ന ഏതെങ്കിലും വലുപ്പത്തിലുള്ള സംഖ്യകൾ, കുറഞ്ഞത്
ചില പ്രോഗ്രാമർമാർക്ക് നൊട്ടേഷൻ പരിചിതമായിരിക്കാം.

ഞാൻ എങ്ങനെയാണ് ഹെക്സാഡെസിമലിനെ ദശാംശത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത്
"0x" നൊട്ടേഷന്റെ പരിവർത്തനത്തിൽ നിർമ്മിച്ച perl ഉപയോഗിക്കുന്നത്:

എന്റെ $dec = 0xDEADBEEF;

"ഹെക്സ്" ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:

എന്റെ $dec = hex("DEADBEEF");

"പാക്ക്" ഉപയോഗിക്കുന്നത്:

എന്റെ $dec = unpack("N", pack("H8", substr("0" x 8 . "DEADBEEF", -8)));

CPAN മൊഡ്യൂൾ "ബിറ്റ്:: വെക്റ്റർ" ഉപയോഗിക്കുന്നു:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്::Vector->new_Hex(32, "DEADBEEF");
എന്റെ $dec = $vec->to_Dec();

ദശാംശത്തിൽ നിന്ന് ഹെക്സാഡെസിമലിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാം
"sprintf" ഉപയോഗിക്കുന്നു:

my $hex = sprintf("%X", 3735928559); # വലിയക്ഷരം AF
my $hex = sprintf("%x", 3735928559); # ചെറിയക്ഷരം af

"അൺപാക്ക്" ഉപയോഗിക്കുന്നത്:

എന്റെ $ഹെക്സ് = അൺപാക്ക്("H*", പാക്ക്("N", 3735928559));

ബിറ്റ് ഉപയോഗിക്കുന്നു::വെക്റ്റർ:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്::Vector->new_Dec(32, -559038737);
എന്റെ $ഹെക്സ് = $vec->to_Hex();

കൂടാതെ ബിറ്റ് :: വെക്റ്റർ ഒറ്റ ബിറ്റ് കൗണ്ടുകളെ പിന്തുണയ്ക്കുന്നു:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്::Vector->new_Dec(33, 3735928559);
$vec->വലിപ്പം മാറ്റുക(32); # ആവശ്യമില്ലെങ്കിൽ ലീഡിംഗ് 0 അടിച്ചമർത്തുക
എന്റെ $ഹെക്സ് = $vec->to_Hex();

അഷ്ടത്തിൽ നിന്ന് ദശാംശത്തിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാം
മുൻനിര പൂജ്യങ്ങളുള്ള സംഖ്യകളുടെ പരിവർത്തനത്തിൽ Perl's ബിൽറ്റ് ഉപയോഗിക്കുന്നു:

എന്റെ $ dec = 033653337357; # മുൻനിര 0 ശ്രദ്ധിക്കുക!

"oct" ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു:

എന്റെ $dec = oct("33653337357");

ബിറ്റ് ഉപയോഗിക്കുന്നു::വെക്റ്റർ:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്:: വെക്റ്റർ->പുതിയ(32);
$vec->Chunk_List_Store(3, split(//, reverse "33653337357"));
എന്റെ $dec = $vec->to_Dec();

ഞാൻ എങ്ങനെയാണ് ദശാംശത്തിൽ നിന്ന് ഒക്ടലിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത്
"sprintf" ഉപയോഗിക്കുന്നു:

എന്റെ $oct = sprintf("%o", 3735928559);

ബിറ്റ് ഉപയോഗിക്കുന്നു::വെക്റ്റർ:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്::Vector->new_Dec(32, -559038737);
എന്റെ $oct = റിവേഴ്സ് ജോയിൻ('', $vec->ചങ്ക്_ലിസ്റ്റ്_വായിക്കുക(3));

ബൈനറിയിൽ നിന്ന് ദശാംശത്തിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാം
"5.6b" നൊട്ടേഷൻ ഉപയോഗിച്ച് നേരിട്ട് ബൈനറി നമ്പറുകൾ എഴുതാൻ Perl 0 നിങ്ങളെ അനുവദിക്കുന്നു:

എന്റെ $നമ്പർ = 0b10110110;

"oct" ഉപയോഗിക്കുന്നത്:

എന്റെ $ഇൻപുട്ട് = "10110110";
എന്റെ $ ഡെസിമൽ = ഒക്ട് ( "0b$ ഇൻപുട്ട്" );

"പാക്ക്", "ഓർഡ്" എന്നിവ ഉപയോഗിക്കുന്നു:

എന്റെ $ ഡെസിമൽ = ഓർഡർ(പാക്ക്('B8', '10110110'));

വലിയ സ്ട്രിംഗുകൾക്ക് "പാക്ക്", "അൺപാക്ക്" എന്നിവ ഉപയോഗിക്കുന്നു:

എന്റെ $int = അൺപാക്ക്("N", പാക്ക്("B32",
substr("0" x 32 . "11110101011011011111011101111", -32)));
എന്റെ $dec = sprintf("%d", $int);

പൂജ്യങ്ങളുള്ള 32 പ്രതീകങ്ങളുള്ള ഒരു സ്ട്രിംഗ് ലെഫ്റ്റ് പാഡ് ചെയ്യാൻ # substr() ഉപയോഗിക്കുന്നു.

ബിറ്റ് ഉപയോഗിക്കുന്നു::വെക്റ്റർ:

my $vec = Bit::Vector->new_Bin(32, "11011110101011011011111011101111");
എന്റെ $dec = $vec->to_Dec();

ദശാംശത്തിൽ നിന്ന് ബൈനറിയിലേക്ക് എങ്ങനെ പരിവർത്തനം ചെയ്യാം
"sprintf" (perl 5.6+) ഉപയോഗിക്കുന്നു:

my $bin = sprintf("%b", 3735928559);

"അൺപാക്ക്" ഉപയോഗിക്കുന്നത്:

എന്റെ $ ബിൻ = അൺപാക്ക് ("ബി*", പാക്ക്("എൻ", 3735928559));

ബിറ്റ് ഉപയോഗിക്കുന്നു::വെക്റ്റർ:

ബിറ്റ്:: വെക്റ്റർ ഉപയോഗിക്കുക;
എന്റെ $vec = ബിറ്റ്::Vector->new_Dec(32, -559038737);
എന്റെ $ബിൻ = $vec->to_Bin();

ശേഷിക്കുന്ന രൂപാന്തരങ്ങൾ (ഉദാ. ഹെക്സ് -> ഒക്ട്, ബിൻ -> ഹെക്സ് മുതലായവ) ഒരു
ചായ്‌വുള്ള വായനക്കാരന് വ്യായാമം ചെയ്യുക.

എന്തുകൊണ്ട് ഇല്ല & വേല The വഴി I ആഗ്രഹിക്കുന്നു it ലേക്ക്?
ബൈനറി ഗണിത ഓപ്പറേറ്റർമാരുടെ പെരുമാറ്റം അവർ അക്കങ്ങളിൽ ഉപയോഗിച്ചിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
ചരടുകൾ. ഓപ്പറേറ്റർമാർ ഒരു സ്ട്രിംഗിനെ ബിറ്റുകളുടെ ഒരു ശ്രേണിയായി കണക്കാക്കുകയും അതിനൊപ്പം പ്രവർത്തിക്കുകയും ചെയ്യുന്നു (സ്ട്രിംഗ്
"3" എന്നത് ബിറ്റ് പാറ്റേൺ 00110011 ആണ്). ഓപ്പറേറ്റർമാർ ഒരു സംഖ്യയുടെ ബൈനറി രൂപത്തിൽ പ്രവർത്തിക്കുന്നു (ദി
നമ്പർ 3 ബിറ്റ് പാറ്റേൺ 00000011 ആയി കണക്കാക്കുന്നു).

അതിനാൽ, "11 & 3" എന്ന് പറയുന്നത് അക്കങ്ങളിൽ "ഒപ്പം" പ്രവർത്തനം നടത്തുന്നു (3 ലഭിക്കുന്നത്). "11" &
"3" സ്ട്രിംഗുകളിൽ "ഒപ്പം" പ്രവർത്തനം നടത്തുന്നു ("1" ലഭിക്കുന്നു).

"&", "|" എന്നിവയിലെ മിക്ക പ്രശ്നങ്ങളും പ്രോഗ്രാമർ തങ്ങൾക്ക് ഒരു നമ്പർ ഉണ്ടെന്ന് കരുതുന്നതിനാൽ ഉണ്ടാകുന്നു
ശരിക്കും അതൊരു സ്ട്രിംഗ് അല്ലെങ്കിൽ തിരിച്ചും ആണ്. ഇത് ഒഴിവാക്കാൻ, വാദങ്ങൾ വ്യക്തമായി കർശനമാക്കുക
("" അല്ലെങ്കിൽ "qq()") അല്ലെങ്കിൽ അവയെ വ്യക്തമായി അക്കങ്ങളാക്കി മാറ്റുക ("0+$arg" ഉപയോഗിച്ച്). വിശ്രമം
പ്രോഗ്രാമർ പറയുന്നതിനാൽ ഉണ്ടാകുന്നു:

എങ്കിൽ ("\020\020" & "\101\101") {
#...
}

എന്നാൽ രണ്ട് നൾ ബൈറ്റുകൾ ("\020\020" & "\101\101" എന്നിവയുടെ ഫലം) അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് ഒരു
പേളിലെ തെറ്റായ മൂല്യം. നിങ്ങൾക്ക് വേണ്ടത്:

എങ്കിൽ ("\020\020" & "\101\101") !~ /[^\000]/) {
#...
}

എങ്ങനെ do I പെരുക്കുക മെട്രിക്സ്?
Math ::Matrix അല്ലെങ്കിൽ Math ::MatrixReal മൊഡ്യൂളുകൾ (CPAN-ൽ നിന്ന് ലഭ്യമാണ്) അല്ലെങ്കിൽ PDL ഉപയോഗിക്കുക
വിപുലീകരണം (CPAN-ൽ നിന്നും ലഭ്യമാണ്).

എങ്ങനെ do I നിർവഹിക്കുക an ഓപ്പറേഷൻ on a പരമ്പര of പൂർണ്ണസംഖ്യകൾ?
ഒരു അറേയിലെ ഓരോ ഘടകത്തിലും ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നതിനും ഫലങ്ങൾ ശേഖരിക്കുന്നതിനും, ഉപയോഗിക്കുക:

എന്റെ @ഫലങ്ങൾ = മാപ്പ് {my_func($_)} @array;

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

എന്റെ @ട്രിപ്പിൾ = മാപ്പ് {3 * $_} @single;

ഒരു അറേയുടെ ഓരോ ഘടകത്തിലും ഒരു ഫംഗ്‌ഷൻ വിളിക്കാൻ, എന്നാൽ ഫലങ്ങൾ അവഗണിക്കുക:

എന്റെ $iterator (@array) {
some_func($iterator);
}

ഒരു (ചെറിയ) ശ്രേണിയിലെ ഓരോ പൂർണ്ണസംഖ്യയിലും ഒരു ഫംഗ്‌ഷൻ വിളിക്കാൻ, നിങ്ങൾ കഴിയും ഉപയോഗം:

എന്റെ @ഫലങ്ങൾ = മാപ്പ് { some_func($_)} (5 .. 25);

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

എന്റെ @ഫലങ്ങൾ = ();
എന്റെ $i (5 .. 500_005) {
പുഷ്(@ഫലങ്ങൾ, some_func($i));
}

അല്ലെങ്കിൽ പോലും

പുഷ്(@ഫലങ്ങൾ, some_func($_)) 5 .. 500_005;

500,000 പൂർണ്ണസംഖ്യകളുടെ ഒരു ഇന്റർമീഡിയറ്റ് ലിസ്റ്റ് സൃഷ്ടിക്കില്ല.

എങ്ങനെ കഴിയും I ഔട്ട്പുട്ട് റോമൻ അക്കങ്ങൾ?
നേടുകhttp://www.cpan.org/modules/by-module/Roman> മൊഡ്യൂൾ.

എന്തുകൊണ്ട് അല്ല my ക്രമരഹിതം നമ്പറുകൾ ക്രമരഹിതമാണോ?
5.004-ന് മുമ്പ് നിങ്ങൾ Perl-ന്റെ ഒരു പതിപ്പാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിങ്ങൾ ആദ്യം "srand" എന്ന് വിളിക്കണം
റാൻഡം നമ്പർ ജനറേറ്റർ സീഡ് ചെയ്യാനുള്ള നിങ്ങളുടെ പ്രോഗ്രാം.

BEGIN { srand() ആണെങ്കിൽ $] < 5.004 }

5.004, പിന്നീട് സ്വയമേവ തുടക്കത്തിൽ "srand" എന്ന് വിളിക്കുന്നു. "srand" എന്നതിൽ കൂടുതൽ വിളിക്കരുത്
ഒരിക്കൽ--നിങ്ങളുടെ സംഖ്യകൾ കൂടുതൽ എന്നതിലുപരി ക്രമരഹിതമാക്കുന്നു.

കമ്പ്യൂട്ടറുകൾ പ്രവചിക്കുന്നതിൽ മികച്ചതും ക്രമരഹിതമായി പ്രവർത്തിക്കുന്നതിൽ മോശവുമാണ് (കാണിച്ചിട്ടും
നിങ്ങളുടെ പ്രോഗ്രാമുകളിലെ ബഗുകൾ കാരണം :-). ദി ക്രമരഹിതം "നിങ്ങളേക്കാൾ വളരെ കൂടുതലാണ്" എന്ന ലേഖനത്തിൽ
അറിയാൻ ആഗ്രഹിക്കുന്നു" എന്ന ശേഖരത്തിൽhttp://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz>, കടപ്പാട്
ടോം ഫീനിക്സ്, ഇതിനെക്കുറിച്ച് കൂടുതൽ സംസാരിക്കുന്നു. ജോൺ വോൺ ന്യൂമാൻ പറഞ്ഞു, "ആരെങ്കിലും ശ്രമിക്കുന്നു
നിർണ്ണായക മാർഗങ്ങളിലൂടെ ക്രമരഹിത സംഖ്യകൾ സൃഷ്ടിക്കുക, തീർച്ചയായും, പാപത്തിന്റെ അവസ്ഥയിലാണ് ജീവിക്കുന്നത്."

"റാൻഡ്", "സ്രാൻഡ്" എന്നിവ നടപ്പിലാക്കുന്നതിനായി പേൾ ആശ്രയിക്കുന്നത് അടിസ്ഥാന സംവിധാനത്തെയാണ്; ചിലതിൽ
സിസ്റ്റങ്ങളിൽ, ജനറേറ്റ് ചെയ്ത നമ്പറുകൾ ക്രമരഹിതമല്ല (പ്രത്യേകിച്ച് വിൻഡോസിൽ : കാണുക
<http://www.perlmonks.org/?node_id=803632>). "മാത്ത്" നെയിംസ്പേസിൽ നിരവധി CPAN മൊഡ്യൂളുകൾ
മികച്ച സ്യൂഡോറാൻഡം ജനറേറ്ററുകൾ നടപ്പിലാക്കുക; ഉദാഹരണത്തിന് നോക്കുക Math::Random::MT ("Mersenne
ട്വിസ്റ്റർ", ഫാസ്റ്റ്), അല്ലെങ്കിൽ ഗണിതം ::ട്രൂലിറാൻഡം (സിസ്റ്റത്തിന്റെ ടൈമറിലെ അപൂർണതകൾ ഉപയോഗിക്കുന്നു
ക്രമരഹിതമായ സംഖ്യകൾ സൃഷ്ടിക്കുക, അത് വളരെ മന്ദഗതിയിലാണ്). ക്രമരഹിത സംഖ്യകൾക്കുള്ള കൂടുതൽ അൽഗോരിതങ്ങൾ
"സിയിലെ സംഖ്യാ പാചകക്കുറിപ്പുകൾ" എന്നതിൽ വിവരിച്ചിരിക്കുന്നുhttp://www.nr.com/>

എങ്ങനെ do I നേടുക a ക്രമരഹിതം അക്കം തമ്മിലുള്ള X ഒപ്പം Y?
രണ്ട് മൂല്യങ്ങൾക്കിടയിൽ ഒരു റാൻഡം നമ്പർ ലഭിക്കുന്നതിന്, നിങ്ങൾക്ക് "rand()" ബിൽറ്റ്-ഇൻ ഉപയോഗിച്ച് ഒരു
0 നും 1 നും ഇടയിലുള്ള ക്രമരഹിത സംഖ്യ. അവിടെ നിന്ന്, നിങ്ങൾക്കത് ആവശ്യമുള്ള ശ്രേണിയിലേക്ക് മാറ്റുക.

"rand($x)" എന്നത് "0 <= rand($x) < $x" എന്ന സംഖ്യ നൽകുന്നു. അങ്ങനെ നിങ്ങൾ ആഗ്രഹിക്കുന്നത്
0 മുതൽ നിങ്ങൾ തമ്മിലുള്ള വ്യത്യാസം വരെയുള്ള ശ്രേണിയിലുള്ള ഒരു ക്രമരഹിത സംഖ്യയാണ് perl ഫിഗർ ഔട്ട് X
ഒപ്പം Y.

അതായത്, 10-നും 15-നും ഇടയിലുള്ള ഒരു സംഖ്യ ലഭിക്കുന്നതിന്, 0-നും ഇടയിൽ ഒരു ക്രമരഹിത സംഖ്യ വേണം.
നിങ്ങൾക്ക് 5-ലേക്ക് ചേർക്കാൻ കഴിയുന്ന 10.

എന്റെ $നമ്പർ = 10 + int rand( 15-10+1 ); # ( 10,11,12,13,14, അല്ലെങ്കിൽ 15 )

അതിനാൽ, അത് അമൂർത്തമാക്കുന്നതിന് നിങ്ങൾ ഇനിപ്പറയുന്ന ലളിതമായ ഫംഗ്ഷൻ എടുക്കുന്നു. ഇത് ഒരു റാൻഡം തിരഞ്ഞെടുക്കുന്നു
നൽകിയിരിക്കുന്ന രണ്ട് പൂർണ്ണസംഖ്യകൾക്കിടയിലുള്ള പൂർണ്ണസംഖ്യ (ഉൾപ്പെടെ). ഉദാഹരണത്തിന്:
"random_int_between(50,120)".

ഉപ random_int_between {
എന്റെ($മിനിറ്റ്, $max) = @_;
# രണ്ട് വാദങ്ങളും പൂർണ്ണസംഖ്യകളാണെന്ന് അനുമാനിക്കുന്നു!
$min == $max എങ്കിൽ $min തിരികെ നൽകുക;
($min, $max) = ($max, $min) എങ്കിൽ $min > $max;
തിരികെ $min + int rand(1 + $max - $min);
}

ഡാറ്റ: തീയതി

എങ്ങനെ do I കണ്ടെത്തുക The ദിവസം or വാരാന്തം of The വർഷം?
"ലോക്കൽടൈം" ഫംഗ്‌ഷൻ നൽകുന്ന ലിസ്റ്റിലാണ് വർഷത്തിലെ ദിവസം. ഒരു ഇല്ലാതെ
"ലോക്കൽടൈം" എന്ന വാദം നിലവിലെ സമയം ഉപയോഗിക്കുന്നു.

എന്റെ $day_of_year = (പ്രാദേശിക സമയം)[7];

POSIX മൊഡ്യൂളിന് ഒരു തീയതി വർഷത്തിലെ ദിവസമോ വർഷത്തിലെ ആഴ്ചയോ ആയി ഫോർമാറ്റ് ചെയ്യാനും കഴിയും.

POSIX qw/strftime/ ഉപയോഗിക്കുക;
എന്റെ $day_of_year = strftime "%j", പ്രാദേശിക സമയം;
എന്റെ $week_of_year = strftime "%W", പ്രാദേശിക സമയം;

ഏത് തീയതിക്കും വർഷത്തിലെ ദിവസം ലഭിക്കാൻ, POSIX-ന്റെ "mktime" ഉപയോഗിച്ച് യുഗം സെക്കൻഡിൽ സമയം കണ്ടെത്തുക
"പ്രാദേശിക സമയം" എന്ന വാദത്തിന്.

POSIX qw/mktime strftime/;
എന്റെ $week_of_year = strftime "%W",
പ്രാദേശിക സമയം( mktime( 0, 0, 0, 18, 11, 87 ) );

നിങ്ങൾക്ക് ടൈം::പീസ് ഉപയോഗിക്കാനും കഴിയും, അത് പേളിനൊപ്പം വരുന്നതും "പ്രാദേശിക സമയം" നൽകുന്നതുമാണ്
ഒരു വസ്തു തിരികെ നൽകുന്നു:

സമയം ഉപയോഗിക്കുക:: കഷണം;
എന്റെ $day_of_year = പ്രാദേശിക സമയം->ദിവസം;
എന്റെ $week_of_year = പ്രാദേശിക സമയം->ആഴ്ച;

ഇവയും കണക്കാക്കാൻ തീയതി:: Calc മൊഡ്യൂൾ രണ്ട് പ്രവർത്തനങ്ങൾ നൽകുന്നു:

ഉപയോഗിക്കുന്ന തീയതി :: Calc;
എന്റെ $day_of_year = Day_of_year( 1987, 12, 18 );
എന്റെ $ആഴ്ച_ഓഫ്_ഇയർ = ആഴ്ച_ഓഫ്_ഇയർ( 1987, 12, 18 );

എങ്ങനെ do I കണ്ടെത്തുക The നിലവിലുള്ളത് നൂറ്റാണ്ട് or സഹസ്രാബ്ദമോ?
ഇനിപ്പറയുന്ന ലളിതമായ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുക:

സബ് get_century {
റിട്ടേൺ ഇൻറ്റ്((((പ്രാദേശിക സമയം(ഷിഫ്റ്റ് || സമയം)))[5] + 1999))/100);
}

സബ് get_millennium {
റിട്ടേൺ 1+int(((((പ്രാദേശിക സമയം(ഷിഫ്റ്റ് || സമയം)))[5] + 1899))/1000);
}

ചില സിസ്റ്റങ്ങളിൽ, POSIX മൊഡ്യൂളിന്റെ "strftime()" ഫംഗ്ഷൻ ഒരു നോൺ-ൽ വിപുലീകരിച്ചിരിക്കുന്നു.
ഒരു %C ഫോർമാറ്റ് ഉപയോഗിക്കുന്നതിനുള്ള സാധാരണ മാർഗം, അവർ ചിലപ്പോൾ "നൂറ്റാണ്ട്" എന്ന് അവകാശപ്പെടുന്നു. അത് അല്ല,
കാരണം, അത്തരം മിക്ക സിസ്റ്റങ്ങളിലും, ഇത് നാലക്ക വർഷത്തിലെ ആദ്യത്തെ രണ്ട് അക്കങ്ങൾ മാത്രമാണ്,
അതിനാൽ നിലവിലെ നൂറ്റാണ്ടോ സഹസ്രാബ്ദമോ വിശ്വസനീയമായി നിർണ്ണയിക്കാൻ ഉപയോഗിക്കാനാവില്ല.

എങ്ങനെ കഴിയും I താരതമ്യം ചെയ്യുക രണ്ട് തീയതികൾ ഒപ്പം കണ്ടെത്തുക The വ്യത്യാസം?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് നിങ്ങളുടെ എല്ലാ തീയതികളും ഒരു സംഖ്യയായി സംഭരിക്കുകയും തുടർന്ന് കുറയ്ക്കുകയും ചെയ്യാം. ജീവിതം എപ്പോഴും അങ്ങനെയല്ല
ലളിതമാണെങ്കിലും.

പേളിനൊപ്പം വരുന്ന സമയം::പീസ് മൊഡ്യൂൾ, പ്രാദേശിക സമയത്തെ ഒരു പതിപ്പ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു
ഒരു വസ്തു തിരികെ നൽകുന്നു. ഇത് താരതമ്യ ഓപ്പറേറ്റർമാരെ ഓവർലോഡ് ചെയ്യുന്നതിനാൽ നിങ്ങൾക്ക് അവരെ താരതമ്യം ചെയ്യാം
നേരിട്ട്:

സമയം ഉപയോഗിക്കുക:: കഷണം;
എന്റെ $date1 = പ്രാദേശിക സമയം( $some_time );
എന്റെ $date2 = പ്രാദേശിക സമയം( $some_other_time );

എങ്കിൽ( $date1 < $date2 ) {
"തീയതി കഴിഞ്ഞ കാലമായിരുന്നു\n";
}

ഒരു സമയം::സെക്കൻഡ്സ് ഒബ്ജക്റ്റ് നൽകുന്ന, കുറയ്ക്കൽ ഉപയോഗിച്ചും നിങ്ങൾക്ക് വ്യത്യാസങ്ങൾ ലഭിക്കും.

എന്റെ $diff = $date1 - $date2;
പ്രിന്റ് "വ്യത്യാസം ", $date_diff->days, " days\n";

നിങ്ങൾക്ക് ഫോർമാറ്റ് ചെയ്ത തീയതികളിൽ പ്രവർത്തിക്കണമെങ്കിൽ, Date::Manip, Date::Calc, അല്ലെങ്കിൽ DateTime മൊഡ്യൂളുകൾ
നിങ്ങളെ സഹായിക്കാൻ കഴിയും.

എങ്ങനെ കഴിയും I എടുക്കുക a സ്ട്രിംഗ് ഒപ്പം വളവ് it കടന്നു യുഗം സെക്കന്റുകൾ?
ഇത് എല്ലായ്പ്പോഴും ഒരേ ഫോർമാറ്റ് ഉള്ള ഒരു സാധാരണ സ്ട്രിംഗ് ആണെങ്കിൽ, നിങ്ങൾക്കത് വിഭജിക്കാം
സ്റ്റാൻഡേർഡ് ടൈം::ലോക്കൽ മൊഡ്യൂളിൽ ഭാഗങ്ങൾ "ടൈംലോക്കൽ" എന്നതിലേക്ക് മാറ്റുക. അല്ലെങ്കിൽ, നിങ്ങൾ
CPAN-ൽ നിന്നുള്ള Date::Calc, Date::Parse, Date::Manip മൊഡ്യൂളുകൾ പരിശോധിക്കണം.

എങ്ങനെ കഴിയും I കണ്ടെത്തുക The ജൂലിയൻ ദിവസം?
(ബ്രയാൻ ഡി ഫോയും ഡേവ് ക്രോസും സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് ടൈം::പീസ് മൊഡ്യൂൾ ഉപയോഗിക്കാം, സ്റ്റാൻഡേർഡ് ലൈബ്രറിയുടെ ഭാഗമാണ്, അതിന് a പരിവർത്തനം ചെയ്യാൻ കഴിയും
ഒരു ജൂലിയൻ ദിനത്തിലേക്കുള്ള തീയതി/സമയം:

$ perl -MTime::Piece -le 'print localtime->julian_day'
2455607.7959375

അല്ലെങ്കിൽ പരിഷ്കരിച്ച ജൂലിയൻ ദിനം:

$ perl -MTime::Piece -le 'print localtime->mjd'
55607.2961226851

അല്ലെങ്കിൽ വർഷത്തിലെ ദിവസം പോലും (ചിലർ ജൂലിയൻ ദിനമായി കരുതുന്നത്):

$ perl -MTime::Piece -le 'print localtime->yday'
45

DateTime മൊഡ്യൂൾ ഉപയോഗിച്ചും നിങ്ങൾക്ക് സമാന കാര്യങ്ങൾ ചെയ്യാൻ കഴിയും:

$ perl -MDateTime -le'print DateTime->today->jd'
2453401.5
$ perl -MDateTime -le'print DateTime->today->mjd'
53401
$ perl -MDateTime -le'print DateTime->today->doy'
31

നിങ്ങൾക്ക് CPAN-ൽ ലഭ്യമായ Time ::JulianDay മൊഡ്യൂൾ ഉപയോഗിക്കാം. നിങ്ങൾ ശരിക്കും ആഗ്രഹിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക
ജൂലിയൻ ദിനങ്ങളെക്കുറിച്ച് പലർക്കും വ്യത്യസ്തമായ ആശയങ്ങൾ ഉള്ളതിനാൽ ജൂലിയൻ ദിനം കണ്ടെത്തുക (കാണുക
<http://www.hermetic.ch/cal_stud/jdn.htm> ഉദാഹരണത്തിന്):

$ perl -MTime::JulianDay -le 'print local_julian_day( time )'
55608

എങ്ങനെ do I കണ്ടെത്തുക ഇന്നലത്തെ തീയതി?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഇത് ശരിയായി ചെയ്യുന്നതിന്, കലണ്ടറുകളിൽ പ്രവർത്തിക്കുന്നതിനാൽ നിങ്ങൾക്ക് "തീയതി" മൊഡ്യൂളുകളിൽ ഒന്ന് ഉപയോഗിക്കാം
സമയത്തിന് പകരം. DateTime മൊഡ്യൂൾ ഇത് ലളിതമാക്കുകയും ദിവസത്തിലെ അതേ സമയം നിങ്ങൾക്ക് നൽകുകയും ചെയ്യുന്നു,
ഡേലൈറ്റ് സേവിംഗ് സമയം മാറിയിട്ടും തലേദിവസം മാത്രം:

DateTime ഉപയോഗിക്കുക;

എന്റെ $ഇന്നലെ = തീയതിസമയം->ഇപ്പോൾ->കുറക്കുക(ദിവസം => 1 );

പ്രിന്റ് "ഇന്നലെ $ഇന്നലെ\n";

നിങ്ങൾക്ക് അതിന്റെ "Today_and_Now" ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് Date ::Calc മൊഡ്യൂളും ഉപയോഗിക്കാം.

തീയതി ഉപയോഗിക്കുക :: Calc qw( Today_and_Now Add_Delta_DHMS );

എന്റെ @date_time = Add_Delta_DHMS( Today_and_Now(), -1, 0, 0, 0 );

"@date_time\n" പ്രിന്റ് ചെയ്യുക;

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

Perl 5.10 മുതൽ ആരംഭിക്കുന്നു, സമയം::പീസ്, സമയം::സെക്കൻഡ് എന്നിവ സ്റ്റാൻഡേർഡിന്റെ ഭാഗമാണ്
വിതരണം, അതിനാൽ നിങ്ങൾക്ക് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ കഴിയുമെന്ന് നിങ്ങൾ ചിന്തിച്ചേക്കാം:

സമയം ഉപയോഗിക്കുക:: കഷണം;
സമയം ഉപയോഗിക്കുക:: സെക്കൻഡ്;

എന്റെ $ഇന്നലെ = പ്രാദേശിക സമയം() - ONE_DAY; # തെറ്റ്
പ്രിന്റ് "ഇന്നലെ $ഇന്നലെ\n";

സമയം::പീസ് മൊഡ്യൂൾ ഒരു പുതിയ "പ്രാദേശിക സമയം" എക്‌സ്‌പോർട്ട് ചെയ്യുന്നു, അത് ഒരു ഒബ്‌ജക്റ്റ് നൽകുന്നു, സമയം::സെക്കൻഡ്
"ONE_DAY" സ്ഥിരാങ്കം എക്‌സ്‌പോർട്ടുചെയ്യുന്നു, അത് ഒരു സെക്കൻറ് സംഖ്യയാണ്. ഇത് എല്ലായ്പ്പോഴും എന്നാണ്
24 മണിക്കൂർ മുമ്പ് സമയം നൽകുന്നു, അത് എല്ലായ്‌പ്പോഴും ഇന്നലെയല്ല. ഇത് ചുറ്റുമുള്ള പ്രശ്നങ്ങൾക്ക് കാരണമാകും
25 മണിക്കൂർ ദൈർഘ്യമുള്ള ഒരു ദിവസം ഉണ്ടാകുമ്പോൾ പകൽ ലാഭിക്കുന്ന സമയത്തിന്റെ അവസാനം.

ടൈം::ലോക്കലിലും നിങ്ങൾക്ക് ഇതേ പ്രശ്‌നമുണ്ട്, അത് അവർക്ക് തെറ്റായ ഉത്തരം നൽകും
അതേ പ്രത്യേക കേസുകൾ:

# സംഭാവന ചെയ്തത് ഗുന്നാർ ഹൽമാർസൺ ആണ്
സമയം ഉപയോഗിക്കുക ::പ്രാദേശികം;
എന്റെ $today = ടൈംലോക്കൽ 0, 0, 12, (പ്രാദേശിക സമയം )[3..5];
എന്റെ ($d, $m, $y) = ( പ്രാദേശിക സമയം $today-86400 )[3..5]; # തെറ്റ്
printf "ഇന്നലെ: %d-%02d-%02d\n", $y+1900, $m+1, $d;

പ്രവർത്തിക്കുന്നുണ്ട് പേൾ ഉണ്ട് a വര്ഷം 2000 or 2038 പ്രശ്‌നമുണ്ടോ? Is പേൾ Y2K അനുസരണമുള്ളത്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

പേളിന് ഒരിക്കലും Y2K പ്രശ്‌നമുണ്ടായിരുന്നില്ല, എന്നിരുന്നാലും Y2K സൃഷ്‌ടിക്കുന്നതിൽ നിന്ന് അത് ആളുകളെ തടഞ്ഞില്ല
സ്വന്തം പ്രശ്നങ്ങൾ. അതിന്റെ ശരിയായ ഉപയോഗത്തിനായി "പ്രാദേശിക സമയം" എന്നതിനായുള്ള ഡോക്യുമെന്റേഷൻ കാണുക.

Perl 5.12 മുതൽ, "ലോക്കൽടൈം", "gmtime" എന്നിവയ്ക്ക് ജനുവരി 03:14:08 കഴിഞ്ഞ തീയതികൾ കൈകാര്യം ചെയ്യാൻ കഴിയും
19, 2038, 32-ബിറ്റ് അടിസ്ഥാനമാക്കിയുള്ള സമയം കവിഞ്ഞൊഴുകുമ്പോൾ. നിങ്ങൾക്ക് ഇപ്പോഴും ഒരു മുന്നറിയിപ്പ് ലഭിച്ചേക്കാം
32-ബിറ്റ് "പേൾ":

% perl5.12 -E 'സ്കേലാർ ലോക്കൽ ടൈം (0x9FFF_FFFFFFF )'
ഹെക്സാഡെസിമൽ സംഖ്യയിൽ -e ലൈൻ 1-ൽ പൂർണ്ണസംഖ്യ ഓവർഫ്ലോ.
ബുധൻ നവംബർ 1 19:42:39 5576711

64-ബിറ്റ് "perl"-ൽ, വളരെക്കാലം പ്രവർത്തിക്കുന്ന പ്രൊജക്റ്റുകൾക്കായി നിങ്ങൾക്ക് ഇതിലും വലിയ തീയതികൾ ലഭിക്കും:

% perl5.12 -E 'scalar gmtime( 0x9FFF_FFFFFFFF )'
വ്യാഴം നവംബർ 2 00:42:39 5576711

ക്ഷയിക്കുന്ന പ്രോട്ടോണുകളുടെ ട്രാക്ക് സൂക്ഷിക്കണമെങ്കിൽ നിങ്ങൾക്ക് ഇപ്പോഴും ഭാഗ്യമില്ല.

ഡാറ്റ: സ്ട്രിംഗ്സ്

എങ്ങനെ do I സാധൂകരിക്കുക ഇൻപുട്ട്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

മൂല്യങ്ങൾ നിങ്ങൾ പ്രതീക്ഷിക്കുന്നതോ സ്വീകരിക്കാൻ ആഗ്രഹിക്കുന്നതോ ആണെന്ന് ഉറപ്പാക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്. കൂടാതെ
perlfaq-ൽ ഞങ്ങൾ ഉൾക്കൊള്ളുന്ന നിർദ്ദിഷ്ട ഉദാഹരണങ്ങൾ, നിങ്ങൾക്ക് മൊഡ്യൂളുകൾ നോക്കാനും കഴിയും
Regexp::Common പോലെയുള്ള മറ്റ് മൊഡ്യൂളുകൾക്കൊപ്പം അവരുടെ പേരുകളിൽ "അസെർട്ട്", "സാധൂകരിക്കുക".

ചില മൊഡ്യൂളുകൾക്ക് ബിസിനസ്::ISBN, പോലുള്ള പ്രത്യേക തരം ഇൻപുട്ടുകൾക്ക് മൂല്യനിർണ്ണയം ഉണ്ട്.
ബിസിനസ്സ്::ക്രെഡിറ്റ്കാർഡ്, ഇമെയിൽ::സാധുതയുള്ളത്, കൂടാതെ ഡാറ്റ::സാധുവാക്കുക::IP.

എങ്ങനെ do I രക്ഷപ്പെടുക a സ്ട്രിംഗ്?
"രക്ഷപ്പെടുക" എന്നതുകൊണ്ട് നിങ്ങൾ ഉദ്ദേശിക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. URL രക്ഷപ്പെടലുകൾ perlfaq9-ൽ കൈകാര്യം ചെയ്യുന്നു. ഷെൽ
ബാക്ക്‌സ്ലാഷ് ("\") പ്രതീകം ഉപയോഗിച്ച് എസ്കേപ്പുകൾ നീക്കം ചെയ്യുന്നു

s/\\(.)/$1/g;

ഇത് "\n" അല്ലെങ്കിൽ "\t" അല്ലെങ്കിൽ മറ്റേതെങ്കിലും പ്രത്യേക രക്ഷപ്പെടലുകൾ വികസിപ്പിക്കില്ല.

എങ്ങനെ do I നീക്കം തുടർച്ചയായ ജോഡി of കഥാപാത്രങ്ങൾ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ജോഡി പ്രതീകങ്ങൾ (അല്ലെങ്കിൽ പ്രതീകങ്ങളുടെ റൺ) കണ്ടെത്താൻ നിങ്ങൾക്ക് സബ്സ്റ്റിറ്റ്യൂഷൻ ഓപ്പറേറ്റർ ഉപയോഗിക്കാം.
ഒരൊറ്റ ഉദാഹരണം ഉപയോഗിച്ച് അവയെ മാറ്റിസ്ഥാപിക്കുക. ഈ പകരക്കാരനിൽ, നമ്മൾ ഒരു കഥാപാത്രത്തെ കണ്ടെത്തുന്നു
"(.)". മെമ്മറി പരാൻതീസിസിൽ പൊരുത്തപ്പെടുന്ന പ്രതീകം "\g1" എന്ന ബാക്ക് റഫറൻസിലും സംഭരിക്കുന്നു
അതേ കാര്യം ഉടൻ തന്നെ പിന്തുടരണമെന്ന് ആവശ്യപ്പെടാൻ ഞങ്ങൾ അത് ഉപയോഗിക്കുന്നു. ഞങ്ങൾ ആ ഭാഗം മാറ്റിസ്ഥാപിക്കുന്നു
$1-ൽ പ്രതീകമുള്ള സ്ട്രിംഗ്.

s/(.)\g1/$1/g;

നമുക്ക് "tr///" എന്ന ലിപ്യന്തരണം ഓപ്പറേറ്ററും ഉപയോഗിക്കാം. ഈ ഉദാഹരണത്തിൽ, തിരയൽ പട്ടിക
ഞങ്ങളുടെ "tr///" എന്നതിന്റെ വശത്ത് ഒന്നും അടങ്ങിയിട്ടില്ല, എന്നാൽ "c" ഓപ്ഷൻ അത് ഉൾക്കൊള്ളുന്നു
എല്ലാം. മാറ്റിസ്ഥാപിക്കൽ ലിസ്റ്റിൽ ഒന്നും അടങ്ങിയിട്ടില്ല, അതിനാൽ ലിപ്യന്തരണം ഏതാണ്ട് a ആണ്
നോ-ഓപ്, കാരണം അത് മാറ്റിസ്ഥാപിക്കില്ല (അല്ലെങ്കിൽ കൂടുതൽ കൃത്യമായി, പ്രതീകം മാറ്റിസ്ഥാപിക്കുക
സ്വയം). എന്നിരുന്നാലും, "s" ഓപ്ഷൻ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്തതും തുടർച്ചയായതുമായ പ്രതീകങ്ങളെ സ്ക്വാഷ് ചെയ്യുന്നു
സ്ട്രിംഗ് അതിനാൽ ഒരു പ്രതീകം അതിന്റെ അടുത്ത് ദൃശ്യമാകില്ല

എന്റെ $str = 'ഹാർലെം'; # നെതർലാൻഡിൽ
$str =~ tr//cs; # ഇപ്പോൾ ഹാർലെം, ന്യൂയോർക്കിലെ പോലെ

എങ്ങനെ do I വിപുലീകരിക്കാൻ ഫംഗ്ഷൻ കോളുകൾ in a സ്ട്രിംഗ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഇത് perlref-ൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്, ഇത് വായിക്കാൻ എളുപ്പമുള്ള കാര്യമല്ലെങ്കിലും, അത് ചെയ്യുന്നു
ജോലി. ഈ ഉദാഹരണങ്ങളിൽ ഓരോന്നിലും, ഉപയോഗിച്ച ബ്രേസിനുള്ളിലെ ഫംഗ്‌ഷനെ ഞങ്ങൾ വിളിക്കുന്നു
ഒരു റഫറൻസ് dereference. നമുക്ക് ഒന്നിൽ കൂടുതൽ റിട്ടേൺ മൂല്യമുണ്ടെങ്കിൽ, നമുക്ക് നിർമ്മിക്കാനും കഴിയും
dereference ഒരു അജ്ഞാത ശ്രേണി. ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഫംഗ്ഷനെ ലിസ്റ്റ് സന്ദർഭത്തിൽ വിളിക്കുന്നു.

പ്രിന്റ് "സമയ മൂല്യങ്ങൾ @{ [localtime] } ആണ്.\n";

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

"സമയം ${\(സ്കെയിലർ പ്രാദേശിക സമയം)} ആണ്.\n"

പ്രിന്റ് "സമയം ${ my $x = പ്രാദേശിക സമയം; \$x }.\n";

നിങ്ങളുടെ ഫംഗ്‌ഷൻ ഇതിനകം ഒരു റഫറൻസ് നൽകുന്നുവെങ്കിൽ, നിങ്ങൾ റഫറൻസ് സൃഷ്‌ടിക്കേണ്ടതില്ല
സ്വയം.

സബ് ടൈംസ്റ്റാമ്പ് {my $t = പ്രാദേശിക സമയം; \$t}

പ്രിന്റ് "സമയം ${ ടൈംസ്റ്റാമ്പ്() } ആണ്.\n";

"ഇന്റർപോളേഷൻ" മൊഡ്യൂളിന് നിങ്ങൾക്കായി ഒരുപാട് മാജിക് ചെയ്യാൻ കഴിയും. നിങ്ങൾക്ക് ഒരു വേരിയബിൾ വ്യക്തമാക്കാം
പേര്, ഈ സാഹചര്യത്തിൽ "E", നിങ്ങൾക്കായി ഇന്റർപോളേഷൻ ചെയ്യുന്ന ഒരു ടൈഡ് ഹാഷ് സജ്ജീകരിക്കാൻ. അതിനുണ്ട്
ഇത് ചെയ്യുന്നതിനുള്ള മറ്റ് നിരവധി രീതികളും.

ഇന്റർപോളേഷൻ E => 'eval' ഉപയോഗിക്കുക;
"സമയ മൂല്യങ്ങൾ $E{localtime()} ആണ്.\n";

മിക്ക കേസുകളിലും, സ്ട്രിംഗ് കോൺകാറ്റനേഷൻ ഉപയോഗിക്കുന്നത് വളരെ എളുപ്പമായിരിക്കും, അത് നിർബന്ധിക്കുകയും ചെയ്യുന്നു
സ്കെയിലർ സന്ദർഭം.

"സമയമാണ്" എന്ന് അച്ചടിക്കുക. പ്രാദേശിക സമയം() . ".\n";

എങ്ങനെ do I കണ്ടെത്തുക പൊരുത്തപ്പെടുത്തൽ / കൂടുണ്ടാക്കൽ എന്തും?
രണ്ട് ഒറ്റ പ്രതീകങ്ങൾക്കിടയിൽ എന്തെങ്കിലും കണ്ടെത്താൻ, "/x([^x]*)x/" പോലുള്ള ഒരു പാറ്റേൺ ലഭിക്കും
$1-ൽ ഇടപെടുന്ന ബിറ്റുകൾ. ഒന്നിലധികം ഒന്നിന്, "/alpha(.*?)omega/" പോലെയുള്ള എന്തെങ്കിലും
ആവശ്യമായി വരും. നെസ്റ്റഡ് പാറ്റേണുകൾ കൂടാതെ/അല്ലെങ്കിൽ സമതുലിതമായ പദപ്രയോഗങ്ങൾക്കായി, വിളിക്കപ്പെടുന്നവ കാണുക
(?PARNO) നിർമ്മാണം (perl 5.10 മുതൽ ലഭ്യമാണ്). CPAN മൊഡ്യൂൾ Regexp::Common സഹായിക്കും
അത്തരം പതിവ് പദപ്രയോഗങ്ങൾ നിർമ്മിക്കുന്നതിന് (പ്രത്യേകിച്ച് Regexp::Common::balanced കൂടാതെ
Regexp::Common:: delimited).

കൂടുതൽ സങ്കീർണ്ണമായ സന്ദർഭങ്ങളിൽ ഒരു പാഴ്സർ എഴുതേണ്ടി വരും, ഒരുപക്ഷേ ഇതിൽ നിന്നുള്ള ഒരു പാഴ്സിംഗ് മൊഡ്യൂൾ ഉപയോഗിച്ചായിരിക്കും
CPAN, Regexp::Grammars, Parse::RecDescent, Parse::Yapp, Text::Balanced, അല്ലെങ്കിൽ Marpa::R2.

എങ്ങനെ do I റിവേഴ്സ് ചെയ്യുക a സ്ട്രിംഗ്?
perlfunc-ൽ "റിവേഴ്സ്" എന്നതിൽ രേഖപ്പെടുത്തിയിരിക്കുന്നതുപോലെ, സ്കെയിലർ സന്ദർഭത്തിൽ "reverse()" ഉപയോഗിക്കുക.

എന്റെ $ റിവേഴ്സ്ഡ് = റിവേഴ്സ് $ സ്ട്രിംഗ്;

എങ്ങനെ do I വിപുലീകരിക്കാൻ ടാബുകൾ in a സ്ട്രിംഗ്?
നിങ്ങൾക്ക് ഇത് സ്വയം ചെയ്യാൻ കഴിയും:

1 അതേസമയം $string =~ s/\t+/' ' x (നീളം($&) * 8 - നീളം($`) % 8)/e;

അല്ലെങ്കിൽ നിങ്ങൾക്ക് ടെക്സ്റ്റ് ::ടാബ്സ് മൊഡ്യൂൾ (സാധാരണ പേൾ ​​വിതരണത്തിന്റെ ഭാഗം) ഉപയോഗിക്കാം.

ടെക്സ്റ്റ് ഉപയോഗിക്കുക ::ടാബുകൾ;
എന്റെ @expanded_lines = Expand(@lines_with_tabs);

എങ്ങനെ do I നവീകരിക്കുക a ഖണ്ഡിക?
ടെക്സ്റ്റ് ഉപയോഗിക്കുക ::റാപ്പ് (സാധാരണ പേൾ ​​വിതരണത്തിന്റെ ഭാഗം):

വാചകം ഉപയോഗിക്കുക :: പൊതിയുക;
പ്രിന്റ് റാപ്പ് ("\t", ' ', @ഖണ്ഡികകൾ);

ടെക്‌സ്‌റ്റിലേക്ക് നിങ്ങൾ നൽകുന്ന ഖണ്ഡികകൾ::റാപ്പിൽ എംബഡഡ് ന്യൂലൈനുകൾ അടങ്ങിയിരിക്കരുത്. വാചകം:: പൊതിയുക
വരികളെ ന്യായീകരിക്കുന്നില്ല (ഫ്ലഷ്-വലത്).

അല്ലെങ്കിൽ CPAN മൊഡ്യൂൾ Text ::Autoformat ഉപയോഗിക്കുക. ഒരു ഉണ്ടാക്കി ഫയലുകൾ ഫോർമാറ്റിംഗ് എളുപ്പത്തിൽ ചെയ്യാം
ഷെൽ അപരനാമം, ഇതുപോലെ:

അപരനാമം fmt="perl -i -MText::Autoformat -n0777 \
-e 'പ്രിന്റ് ഓട്ടോഫോർമാറ്റ് $_, {all=>1}' $*"

ടെക്‌സ്‌റ്റ്::ഓട്ടോഫോർമാറ്റിന്റെ നിരവധി കഴിവുകൾ മനസ്സിലാക്കാൻ ഡോക്യുമെന്റേഷൻ കാണുക.

എങ്ങനെ കഴിയും I പ്രവേശനം or മാറ്റം N പ്രതീകങ്ങൾ of a സ്ട്രിംഗ്?
ഇതുപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗിന്റെ ആദ്യ പ്രതീകങ്ങൾ ആക്സസ് ചെയ്യാൻ കഴിയും substr(). ആദ്യത്തേത് ലഭിക്കാൻ
പ്രതീകം, ഉദാഹരണത്തിന്, സ്ഥാനം 0-ൽ ആരംഭിച്ച് നീളം 1-ന്റെ സ്ട്രിംഗ് പിടിക്കുക.

എന്റെ $string = "മറ്റൊരു പേൾ ഹാക്കർ";
എന്റെ $first_char = substr ($string, 0, 1 ); # 'ജെ'

ഒരു സ്ട്രിംഗിന്റെ ഭാഗം മാറ്റുന്നതിന്, നിങ്ങൾക്ക് ഓപ്ഷണൽ നാലാമത്തെ ആർഗ്യുമെന്റ് ഉപയോഗിക്കാം
മാറ്റിസ്ഥാപിക്കൽ സ്ട്രിംഗ്.

substr( $string, 13, 4, "Perl 5.8.0" );

നിങ്ങൾക്ക് ഉപയോഗിക്കാം substr() ഒരു മൂല്യമായി.

substr( $string, 13, 4 ) = "Perl 5.8.0";

എങ്ങനെ do I മാറ്റം The എൻ.ടി സംഭവം of എന്തെങ്കിലും?
നിങ്ങൾ തന്നെ N-ന്റെ ട്രാക്ക് സൂക്ഷിക്കണം. ഉദാഹരണത്തിന്, അഞ്ചാമത്തേത് മാറ്റാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് പറയാം
"ആരെങ്കിലും" അല്ലെങ്കിൽ "ആരെങ്കിലും" "ആരെങ്കിലും" അല്ലെങ്കിൽ "ആരെങ്കിലും" സംഭവിക്കുന്നത്, കേസ്
നിർവികാരമായി. $_ എന്നതിൽ മാറ്റം വരുത്തേണ്ട സ്‌ട്രിംഗ് ഉണ്ടെന്ന് ഇവയെല്ലാം അനുമാനിക്കുന്നു.

$ എണ്ണം = 0;
s{((ആരാണ്?)എന്നെങ്കിലും)}
++$എണ്ണം == 5 # ഇത് അഞ്ചാമത്തേതാണോ?
? "${2}എങ്കിലും" # അതെ, സ്വാപ്പ്
: $1 # നിരസിച്ച് അവിടെ ഉപേക്ഷിക്കുക
}ഇജ്;

കൂടുതൽ പൊതുവായ സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് ഒരു "വെയിൽ" ലൂപ്പിൽ "/g" മോഡിഫയർ ഉപയോഗിക്കാം.
മത്സരങ്ങളുടെ.

$WANT = 3;
$ എണ്ണം = 0;
$_ = "ഒരു മത്സ്യം രണ്ട് മത്സ്യം ചുവന്ന മത്സ്യം നീല മത്സ്യം";
അതേസമയം (/(\w+)\s+മീൻ\b/gi) {
എങ്കിൽ (++$count == $WANT) {
"മൂന്നാം മത്സ്യം $1 ആണ്.\n";
}
}

അത് പ്രിന്റ് ചെയ്യുന്നു: "മൂന്നാമത്തെ മത്സ്യം ചുവന്നതാണ്." നിങ്ങൾക്ക് ഒരു ആവർത്തന എണ്ണവും ഉപയോഗിക്കാം
ഇതുപോലെ ആവർത്തിച്ചുള്ള പാറ്റേൺ:

/(?:\w+\s+fish\s+){2}(\w+)\s+fish/i;

എങ്ങനെ കഴിയും I എണ്ണുക The അക്കം of സംഭവങ്ങൾ of a സബ്സ്ട്രിംഗ് ഉള്ളിൽ a സ്ട്രിംഗ്?
വ്യത്യസ്തമായ കാര്യക്ഷമതയോടെ നിരവധി മാർഗങ്ങളുണ്ട്. നിങ്ങൾക്ക് ഒരു നിശ്ചിത എണ്ണം വേണമെങ്കിൽ
ഒരു സ്‌ട്രിംഗിനുള്ളിൽ ഒറ്റ പ്രതീകം (X), നിങ്ങൾക്ക് "tr///" ഫംഗ്‌ഷൻ ഇതുപോലെ ഉപയോഗിക്കാം:

my $string = "ThisXlineXhasXsomeXx'sXinXit";
എന്റെ $ എണ്ണം = ($ string =~ tr/X//);
"സ്ട്രിംഗിൽ $count X പ്രതീകങ്ങൾ ഉണ്ട്" എന്ന് അച്ചടിക്കുക;

നിങ്ങൾ ഒരു കഥാപാത്രത്തെ മാത്രം തിരയുകയാണെങ്കിൽ ഇത് നല്ലതാണ്. എന്നിരുന്നാലും, നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ
ഒരു വലിയ സ്‌ട്രിംഗിനുള്ളിൽ ഒന്നിലധികം പ്രതീക സബ്‌സ്‌ട്രിംഗുകൾ എണ്ണുക, "tr///" പ്രവർത്തിക്കില്ല. നീ എന്താ
ഒരു പൊതിയുക എന്നതാണ് ചെയ്യാൻ കഴിയുന്നത് അതേസമയം() ഒരു ആഗോള പാറ്റേൺ പൊരുത്തം ചുറ്റും ലൂപ്പ്. ഉദാഹരണത്തിന്, നമുക്ക് കണക്കാക്കാം
നെഗറ്റീവ് പൂർണ്ണസംഖ്യകൾ:

എന്റെ $ സ്ട്രിംഗ് = "-9 55 48 -2 23 -76 4 14 -44";
എന്റെ $എണ്ണം = 0;
അതേസമയം ($string =~ /-\d+/g) {$count++}
"സ്ട്രിംഗിൽ $count നെഗറ്റീവ് നമ്പറുകൾ ഉണ്ട്" എന്ന് അച്ചടിക്കുക;

മറ്റൊരു പതിപ്പ് ലിസ്റ്റ് സന്ദർഭത്തിൽ ഒരു ആഗോള പൊരുത്തം ഉപയോഗിക്കുന്നു, തുടർന്ന് ഫലം ഒരു സ്കെയിലറിലേക്ക് നിയോഗിക്കുന്നു,
പൊരുത്തങ്ങളുടെ എണ്ണത്തിന്റെ ഒരു കണക്ക് നിർമ്മിക്കുന്നു.

എന്റെ $എണ്ണം = () = $string =~ /-\d+/g;

എങ്ങനെ do I മുതലാക്കുക എല്ലാം The വാക്കുകൾ on ഒന്ന് വരി?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഡാമിയൻ കോൺവേയുടെ വാചകം::ഓട്ടോഫോർമാറ്റ് നിങ്ങൾക്കുള്ള എല്ലാ ചിന്തകളും കൈകാര്യം ചെയ്യുന്നു.

ടെക്സ്റ്റ് ഉപയോഗിക്കുക ::ഓട്ടോഫോർമാറ്റ്;
എന്റെ $x = "ഡോ. സ്ട്രേഞ്ച്ലോവ് അല്ലെങ്കിൽ: ഞാൻ എങ്ങനെ നിർത്താൻ പഠിച്ചു ".
"ആകുലപ്പെടുകയും ബോംബിനെ സ്നേഹിക്കുകയും ചെയ്യുക";

$x, "\n" പ്രിന്റ് ചെയ്യുക;
എന്റെ $സ്‌റ്റൈലിനായി (qw(വാക്യ ശീർഷകം ഹൈലൈറ്റ്)) {
പ്രിന്റ് ഓട്ടോഫോർമാറ്റ്($x, {case => $style }), "\n";
}

ആ വാക്കുകൾ എങ്ങനെ വലിയക്ഷരമാക്കാനാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത്?

ഫ്രെഡിന്റെയും ബാർണിയുടെയും ലോഡ്ജ് # എല്ലാം വലിയക്ഷരം
ഫ്രെഡ് ആൻഡ് ബാർണിയുടെ ലോഡ്ജ് # ടൈറ്റിൽ കേസ്
ഫ്രെഡ് ആൻഡ് ബാർണീസ് ലോഡ്ജ് # ഹൈലൈറ്റ് കേസ്

ഇത് കാണുന്നത് പോലെ എളുപ്പമുള്ള ഒരു പ്രശ്നമല്ല. അതിൽ എത്ര വാക്കുകൾ ഉണ്ടെന്ന് നിങ്ങൾ കരുതുന്നു? കാത്തിരിക്കുക
അത്... അതിനായി കാത്തിരിക്കൂ.... നിങ്ങൾ 5 ന് ഉത്തരം നൽകിയെങ്കിൽ നിങ്ങൾ പറഞ്ഞത് ശരിയാണ്. പേൾ വാക്കുകൾ "\w+" ഗ്രൂപ്പുകളാണ്, പക്ഷേ
നിങ്ങൾ മുതലാക്കാൻ ആഗ്രഹിക്കുന്നത് അതല്ല. മുതലാക്കരുതെന്ന് പേളിന് എങ്ങനെ അറിയാം
അപ്പോസ്‌ട്രോഫിക്ക് ശേഷമുള്ള "s"? നിങ്ങൾക്ക് ഒരു സാധാരണ പദപ്രയോഗം പരീക്ഷിക്കാം:

$string =~ s/ (
(^\w) #വരിയുടെ തുടക്കത്തിൽ
| # അഥവാ
(\s\w) #മുമ്പ് വൈറ്റ്‌സ്‌പെയ്‌സ്
)
/\U$1/xg;

$string =~ s/([\w']+)/\u\L$1/g;

ഇപ്പോൾ, അത് "കൂടാതെ" വലിയക്ഷരമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ എന്തുചെയ്യും? ടെക്‌സ്‌റ്റ്::ഓട്ടോഫോർമാറ്റ് ഉപയോഗിക്കുക, തുടർന്ന് കയറുക
അടുത്ത പ്രശ്നത്തോടൊപ്പം. :)

എങ്ങനെ കഴിയും I രണ്ടായി പിരിയുക a [കഥാപാത്രം]-ഡീലിമിറ്റഡ് സ്ട്രിംഗ് ഒഴികെ എപ്പോൾ ഉള്ളിൽ [കഥാപാത്രം]?
നിരവധി മൊഡ്യൂളുകൾക്ക് ഇത്തരത്തിലുള്ള പാഴ്‌സിംഗ് കൈകാര്യം ചെയ്യാൻ കഴിയും--ടെക്‌സ്റ്റ്::ബാലൻസ്ഡ്, ടെക്‌സ്‌റ്റ്::CSV, ടെക്‌സ്‌റ്റ്::CSV_XS,
കൂടാതെ വാചകം::ParseWords, മറ്റുള്ളവയിൽ.

കോമയാൽ വേർതിരിക്കപ്പെട്ട ഒരു സ്ട്രിംഗ് വിഭജിക്കാൻ ശ്രമിക്കുന്നതിന്റെ ഉദാഹരണം എടുക്കുക
വ്യത്യസ്ത ഫീൽഡുകൾ. നിങ്ങൾക്ക് "സ്പ്ലിറ്റ്(/,/)" ഉപയോഗിക്കാൻ കഴിയില്ല, കാരണം കോമ ആണെങ്കിൽ നിങ്ങൾ വിഭജിക്കരുത്
ഉദ്ധരണികൾക്കുള്ളിൽ. ഉദാഹരണത്തിന്, ഇതുപോലുള്ള ഒരു ഡാറ്റ ലൈൻ എടുക്കുക:

SAR001,"","Cimetrix, Inc","Bob Smith","CAM",N,8,1,0,7,"Error, Core Dumped"

ഉദ്ധരണികളുടെ നിയന്ത്രണം കാരണം, ഇത് വളരെ സങ്കീർണ്ണമായ ഒരു പ്രശ്നമാണ്. നന്ദി, ഞങ്ങൾ
രചയിതാവ് ജെഫ്രി ഫ്രൈഡൽ ഉണ്ട് മാസ്റ്റേജിംഗ് പതിവ് ഭാവങ്ങൾ, നമുക്ക് വേണ്ടി ഇവ കൈകാര്യം ചെയ്യാൻ. അവൻ
നിർദ്ദേശിക്കുന്നു (നിങ്ങളുടെ സ്‌ട്രിംഗ് $ടെക്‌സ്റ്റിൽ അടങ്ങിയിട്ടുണ്ടെന്ന് കരുതുക):

എന്റെ @പുതിയ = ();
പുഷ്(@പുതിയത്, $+) അതേസമയം $ടെക്സ്റ്റ് =~ m{
"([^\"\\]*(?:\\.[^\"\\]*)*)",? ഉദ്ധരണികൾക്കുള്ളിലെ വാക്യം # ഗ്രൂപ്പുചെയ്യുക
| ([^,]+),?
| ,
}ജിഎക്സ്;
push(@new, undef) substr($text,-1,1) eq ',';

ഉദ്ധരണി അടയാളം-ഡിലിമിറ്റഡ് ഫീൽഡിനുള്ളിൽ ഉദ്ധരണി ചിഹ്നങ്ങളെ പ്രതിനിധീകരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, രക്ഷപ്പെടുക
ബാക്ക്‌സ്ലാഷുകളുള്ള അവ (ഉദാ, "ഇത് പോലെ \"".

പകരമായി, ടെക്സ്റ്റ്:: പാർസ്വേഡ്സ് മൊഡ്യൂൾ (സാധാരണ പേൾ ​​വിതരണത്തിന്റെ ഭാഗം) അനുവദിക്കുന്നു
നീ പറയു:

വാചകം ഉപയോഗിക്കുക ::ParseWords;
@പുതിയ = ഉദ്ധരണികൾ(",", 0, $വാചകം);

CSV പാഴ്‌സ് ചെയ്യുന്നതിനോ സൃഷ്‌ടിക്കുന്നതിനോ, അത് നടപ്പിലാക്കുന്നതിനുപകരം ടെക്‌സ്‌റ്റ്::CSV ഉപയോഗിക്കുന്നു
സ്വയം വളരെ ശുപാർശ ചെയ്യുന്നു; പിന്നീട് പ്രത്യക്ഷപ്പെടുന്ന വിചിത്രമായ ബഗുകൾ നിങ്ങൾ സ്വയം രക്ഷിക്കും
വർഷങ്ങളായി ഉൽപ്പാദനത്തിൽ പരീക്ഷിച്ചുനോക്കിയ കോഡ് ഉപയോഗിക്കുന്നു.

എങ്ങനെ do I സ്ട്രിപ്പ് ശൂന്യമാണ് ഇടം നിന്ന് The തുടക്കം/അവസാനം of a സ്ട്രിംഗ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഒരു പകരക്കാരന് നിങ്ങൾക്കായി ഇത് ചെയ്യാൻ കഴിയും. ഒരൊറ്റ വരിക്ക്, എല്ലാ മുൻനിരയിലുള്ളവയും മാറ്റിസ്ഥാപിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു
അല്ലെങ്കിൽ ഒന്നുമില്ലാതെ വൈറ്റ്‌സ്‌പെയ്‌സിന് പിന്നിൽ. ഒരു ജോടി പകരക്കാരനായി നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും:

s/^\s+//;
s/\s+$//;

സംയോജിതമായി മാറുന്നുണ്ടെങ്കിലും, ഒരൊറ്റ പകരക്കാരനായി നിങ്ങൾക്ക് അത് എഴുതാനും കഴിയും
പ്രസ്‌താവന വ്യത്യസ്‌തമായവയെക്കാൾ മന്ദഗതിയിലാണ്. അത് നിങ്ങൾക്ക് പ്രശ്നമല്ലായിരിക്കാം, എന്നിരുന്നാലും:

s/^\s+|\s+$//g;

ഈ പതിവ് പദപ്രയോഗത്തിൽ, ആൾട്ടർനേഷൻ തുടക്കത്തിലോ അവസാനത്തിലോ പൊരുത്തപ്പെടുന്നു
ആങ്കറുകൾക്ക് ആൾട്ടർനേഷനേക്കാൾ കുറഞ്ഞ മുൻഗണന ഉള്ളതിനാൽ സ്ട്രിംഗ്. "/g" ഉപയോഗിച്ച്
ഫ്ലാഗ്, സബ്സ്റ്റിറ്റ്യൂഷൻ സാധ്യമായ എല്ലാ പൊരുത്തങ്ങളും ഉണ്ടാക്കുന്നു, അതിനാൽ ഇത് രണ്ടും ലഭിക്കുന്നു. ഓർക്കുക, പിന്നിൽ
"\s+" എന്നതുമായി ന്യൂലൈൻ പൊരുത്തപ്പെടുന്നു, കൂടാതെ "$" ആങ്കറിന് പൂർണ്ണമായ അവസാനവുമായി പൊരുത്തപ്പെടാൻ കഴിയും
സ്ട്രിംഗ്, അതിനാൽ ന്യൂലൈനും അപ്രത്യക്ഷമാകുന്നു. ഔട്ട്‌പുട്ടിലേക്ക് ന്യൂലൈൻ ചേർക്കുക, അതിൽ ഉണ്ട്
"ബ്ലാങ്ക്" (മുഴുവൻ വൈറ്റ്‌സ്‌പെയ്‌സ് അടങ്ങിയ) ലൈനുകൾ സംരക്ഷിക്കുന്നതിന്റെ അധിക നേട്ടം
"^\s+" എല്ലാം തന്നെ നീക്കം ചെയ്യും:

അതേസമയം ( <> ) {
s/^\s+|\s+$//g;
"$_\n" പ്രിന്റ് ചെയ്യുക;
}

ഒരു മൾട്ടി-ലൈൻ സ്‌ട്രിങ്ങിന്, ലെ ഓരോ ലോജിക്കൽ ലൈനിലും നിങ്ങൾക്ക് റെഗുലർ എക്സ്പ്രഷൻ പ്രയോഗിക്കാൻ കഴിയും
"/m" ഫ്ലാഗ് ("മൾട്ടി-ലൈൻ" എന്നതിന്) ചേർത്തുകൊണ്ട് സ്ട്രിംഗ്. "/m" ഫ്ലാഗിനൊപ്പം, "$" പൊരുത്തപ്പെടുന്നു
മുമ്പ് ഒരു ഉൾച്ചേർത്ത ന്യൂലൈൻ, അതിനാൽ അത് നീക്കം ചെയ്യുന്നില്ല. ഈ പാറ്റേൺ ഇപ്പോഴും നീക്കംചെയ്യുന്നു
സ്ട്രിംഗിന്റെ അവസാനം ന്യൂലൈൻ:

$string =~ s/^\s+|\s+$//gm;

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

$string =~ s/^[\t\f ]+|[\t\f ]+$//mg;

എങ്ങനെ do I പാഡ് a സ്ട്രിംഗ് കൂടെ ശൂന്യമാണ് or പാഡ് a അക്കം കൂടെ പൂജ്യങ്ങൾ?
ഇനിപ്പറയുന്ന ഉദാഹരണങ്ങളിൽ, $pad_len എന്നത് നിങ്ങൾ സ്ട്രിംഗ് പാഡ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ദൈർഘ്യമാണ്,
$text അല്ലെങ്കിൽ $num എന്നതിൽ പാഡ് ചെയ്യേണ്ട സ്‌ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു, $pad_char-ൽ പാഡിംഗ് അടങ്ങിയിരിക്കുന്നു
സ്വഭാവം. $pad_char-ന് പകരം നിങ്ങൾക്ക് ഒരൊറ്റ പ്രതീക സ്ട്രിംഗ് സ്ഥിരാങ്കം ഉപയോഗിക്കാം
വേരിയബിൾ എന്താണെന്ന് മുൻകൂട്ടി അറിയാമെങ്കിൽ. അതേ രീതിയിൽ നിങ്ങൾക്ക് ഒരു പൂർണ്ണസംഖ്യ ഉപയോഗിക്കാം
നിങ്ങൾക്ക് പാഡിന്റെ നീളം മുൻകൂട്ടി അറിയാമെങ്കിൽ $pad_len എന്ന സ്ഥലം.

ഏറ്റവും ലളിതമായ രീതി "sprintf" ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. ഇത് ഇടത്തോട്ടോ വലത്തോട്ടോ പാഡ് ചെയ്യാം
ശൂന്യവും ഇടതുവശത്തും പൂജ്യങ്ങളുള്ളതിനാൽ അത് ഫലം വെട്ടിച്ചുരുക്കില്ല. "പാക്ക്"
ഫംഗ്‌ഷന് വലതുവശത്തുള്ള സ്ട്രിംഗുകൾ ബ്ലാങ്കുകൾ ഉപയോഗിച്ച് മാത്രമേ പാഡ് ചെയ്യാൻ കഴിയൂ, അത് ഫലത്തെ ചുരുക്കും
പരമാവധി നീളം $pad_len.

# ശൂന്യതയുള്ള ഒരു സ്ട്രിംഗ് ഇടത് പാഡിംഗ് (വെട്ടിമാറ്റില്ല):
എന്റെ $padded = sprintf("%${pad_len}s", $text);
എന്റെ $padded = sprintf("%*s", $pad_len, $text); #അതേ കാര്യം

# ശൂന്യതയുള്ള ഒരു സ്ട്രിംഗ് വലത് പാഡിംഗ് (ചുരുക്കലില്ല):
എന്റെ $padded = sprintf("%-${pad_len}s", $text);
എന്റെ $padded = sprintf("%-*s", $pad_len, $text); #അതേ കാര്യം

# 0 ഉള്ള ഒരു നമ്പർ ഇടത് പാഡിംഗ് (ചുരുക്കലില്ല):
എന്റെ $padded = sprintf("%0${pad_len}d", $num);
എന്റെ $padded = sprintf("%0*d", $pad_len, $num); #അതേ കാര്യം

# പായ്ക്ക് ഉപയോഗിച്ച് ശൂന്യതയുള്ള ഒരു സ്ട്രിംഗ് വലത് പാഡിംഗ് (ചുരുക്കിമാറ്റും):
എന്റെ $padded = പായ്ക്ക് ("A$pad_len",$text);

നിങ്ങൾക്ക് ശൂന്യമോ പൂജ്യമോ അല്ലാതെ മറ്റൊരു പ്രതീകം ഉപയോഗിച്ച് പാഡ് ചെയ്യണമെങ്കിൽ അതിലൊന്ന് ഉപയോഗിക്കാം
ഇനിപ്പറയുന്ന രീതികൾ. അവയെല്ലാം "x" ഓപ്പറേറ്ററുമായി ഒരു പാഡ് സ്ട്രിംഗ് സൃഷ്ടിക്കുകയും അത് സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു
$ ടെക്സ്റ്റ് ഉപയോഗിച്ച്. ഈ രീതികൾ $text വെട്ടിച്ചുരുക്കുന്നില്ല.

ഒരു പുതിയ സ്ട്രിംഗ് സൃഷ്‌ടിച്ച് ഏത് പ്രതീകത്തിലുമുള്ള ഇടത്തും വലത്തും പാഡിംഗ്:

എന്റെ $padded = $pad_char x ($pad_len - length($text) ) . $ ടെക്സ്റ്റ്;
എന്റെ $padded = $text . $pad_char x ( $pad_len - length( $text ) );

ഏതെങ്കിലും പ്രതീകം ഉപയോഗിച്ച് ഇടത്തും വലത്തും പാഡിംഗ്, $ടെക്‌സ്റ്റ് നേരിട്ട് പരിഷ്‌ക്കരിക്കുന്നു:

substr ($text, 0, 0 ) = $pad_char x ($pad_len - length($text ) );
$text .= $pad_char x ($pad_len - length( $text ) );

എങ്ങനെ do I സത്തിൽ തിരഞ്ഞെടുത്ത നിരകൾ നിന്ന് a സ്ട്രിംഗ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഡാറ്റ അടങ്ങിയിരിക്കുന്ന കോളങ്ങൾ നിങ്ങൾക്ക് അറിയാമെങ്കിൽ, ഒരൊറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാൻ നിങ്ങൾക്ക് "substr" ഉപയോഗിക്കാം
കോളം.

എന്റെ $കോളം = substr( $line, $start_column, $length );

കോളങ്ങൾ വൈറ്റ്‌സ്‌പെയ്‌സ് അല്ലെങ്കിൽ മറ്റേതെങ്കിലും ഡിലിമിറ്റർ ഉപയോഗിച്ച് വേർതിരിക്കുകയാണെങ്കിൽ നിങ്ങൾക്ക് "സ്പ്ലിറ്റ്" ഉപയോഗിക്കാം
വൈറ്റ്‌സ്‌പെയ്‌സ് അല്ലെങ്കിൽ ഡിലിമിറ്റർ ഡാറ്റയുടെ ഭാഗമായി ദൃശ്യമാകാത്തിടത്തോളം.

എന്റെ $ലൈൻ = 'ഫ്രെഡ് ബാർണി ബെറ്റി';
എന്റെ @നിരകൾ = സ്പ്ലിറ്റ് /\s+/, $ലൈൻ;
# ( '', 'ഫ്രെഡ്', 'ബാർണി', 'ബെറ്റി' );

എന്റെ $ലൈൻ = 'ഫ്രെഡ്||ബാർണി||ബെറ്റി';
എന്റെ @നിരകൾ = പിളർപ്പ് /\|/, $ലൈൻ;
# ('ഫ്രെഡ്', '', 'ബാർണി', '', 'ബെറ്റി' );

കോമയാൽ വേർതിരിച്ച മൂല്യങ്ങളുമായി പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ആ ഫോർമാറ്റ് അൽപ്പം ആയതിനാൽ ഇത് ചെയ്യരുത്
കൂടുതൽ സങ്കീർണ്ണമായ. ടെക്സ്റ്റ്::CSV, പോലുള്ള ആ ഫോർമാറ്റ് കൈകാര്യം ചെയ്യുന്ന മൊഡ്യൂളുകളിൽ ഒന്ന് ഉപയോഗിക്കുക
ടെക്സ്റ്റ്::CSV_XS, അല്ലെങ്കിൽ ടെക്സ്റ്റ്::CSV_PP.

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

എന്റെ @ഫീൽഡുകൾ = അൺപാക്ക് ($ലൈൻ, "A8 A8 A8 A16 A4" );

"അൺപാക്ക്" എന്ന ഫോർമാറ്റ് ആർഗ്യുമെന്റിലെ സ്‌പെയ്‌സുകൾ ലിറ്ററൽ സ്‌പെയ്‌സുകളെ സൂചിപ്പിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾ എങ്കിൽ
സ്‌പേസ് വേർതിരിക്കുന്ന ഡാറ്റയുണ്ട്, പകരം നിങ്ങൾക്ക് "വിഭജനം" ആവശ്യമായി വന്നേക്കാം.

എങ്ങനെ do I കണ്ടെത്തുക The soundex മൂല്യം of a സ്ട്രിംഗ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് "ടെക്സ്റ്റ്:: സൗണ്ടെക്സ്" മൊഡ്യൂൾ ഉപയോഗിക്കാം. നിങ്ങൾക്ക് അവ്യക്തമായ അല്ലെങ്കിൽ അടുത്ത പൊരുത്തപ്പെടുത്തൽ നടത്തണമെങ്കിൽ, നിങ്ങൾ
String::Aprox, ടെക്സ്റ്റ്::Metaphone, Text::DoubleMetaphone മൊഡ്യൂളുകളും പരീക്ഷിച്ചേക്കാം.

എങ്ങനെ കഴിയും I വിപുലീകരിക്കാൻ വേരിയബിളുകൾ in ടെക്സ്റ്റ് ചരടുകൾ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് അത് ഒഴിവാക്കാൻ കഴിയുമെങ്കിൽ, ചെയ്യരുത്, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ടെക്സ്റ്റ്::ടെംപ്ലേറ്റ് പോലുള്ള ഒരു ടെംപ്ലേറ്റിംഗ് സിസ്റ്റം ഉപയോഗിക്കാനാകുമെങ്കിൽ
അല്ലെങ്കിൽ ടെംപ്ലേറ്റ് ടൂൾകിറ്റ്, പകരം അത് ചെയ്യുക. നിങ്ങൾക്ക് ജോലി പൂർത്തിയാക്കാൻ പോലും കഴിഞ്ഞേക്കും
"sprintf" അല്ലെങ്കിൽ "printf":

my $string = sprintf '%s, %s എന്നിവരോട് ഹലോ പറയുക', $foo, $bar;

എന്നിരുന്നാലും, ഒരു പൂർണ്ണമായ ടെംപ്ലേറ്റിംഗ് പുറത്തെടുക്കാൻ ഞാൻ ആഗ്രഹിക്കാത്ത ഒറ്റത്തവണ ലളിതമായ കേസിൽ
സിസ്റ്റം, രണ്ട് Perl സ്കെയിലർ വേരിയബിളുകൾ ഉള്ള ഒരു സ്ട്രിംഗ് ഞാൻ ഉപയോഗിക്കും. ഈ ഉദാഹരണത്തിൽ, ഐ
$foo, $bar എന്നിവ അവയുടെ വേരിയബിളിന്റെ മൂല്യങ്ങളിലേക്ക് വികസിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു:

എന്റെ $foo = 'Fred';
എന്റെ $ബാർ = 'ബാർണി';
$string = '$foo, $bar എന്നിവരോട് ഹലോ പറയൂ';

എനിക്ക് ഇത് ചെയ്യാൻ കഴിയുന്ന ഒരു മാർഗ്ഗം സബ്സ്റ്റിറ്റ്യൂഷൻ ഓപ്പറേറ്ററും ഇരട്ട "/e" ഫ്ലാഗും ഉൾപ്പെടുന്നു. ആദ്യത്തേത്
"/e" മാറ്റിസ്ഥാപിക്കുന്ന ഭാഗത്ത് $1 മൂല്യനിർണ്ണയം ചെയ്യുകയും $foo ആക്കി മാറ്റുകയും ചെയ്യുന്നു. രണ്ടാമത്തെ / ഇ ആരംഭിക്കുന്നു
$foo ഉപയോഗിച്ച് അതിനെ അതിന്റെ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. $foo, അപ്പോൾ, 'ഫ്രെഡ്' ആയി മാറുന്നു, അതാണ്
ഒടുവിൽ സ്ട്രിംഗിൽ അവശേഷിക്കുന്നത്:

$string =~ s/(\$\w+)/$1/eeg; # 'ഫ്രെഡിനോടും ബാർണിയോടും ഹലോ പറയുക'

"/e" കർശനമായ ലംഘനങ്ങളെ നിശ്ശബ്ദമായി അവഗണിക്കും, നിർവചിക്കാത്ത വേരിയബിളിനെ മാറ്റിസ്ഥാപിക്കും
ശൂന്യമായ സ്ട്രിംഗുള്ള പേരുകൾ. ഞാൻ "/e" ഫ്ലാഗ് ഉപയോഗിക്കുന്നതിനാൽ (രണ്ടുതവണ പോലും!), എനിക്ക് എല്ലാം ഉണ്ട്
"eval" എന്നതിന്റെ സ്ട്രിംഗ് രൂപത്തിൽ എനിക്കുള്ള അതേ സുരക്ഷാ പ്രശ്നങ്ങൾ. വിചിത്രമായ എന്തെങ്കിലും ഉണ്ടെങ്കിൽ
$foo-ൽ, ഒരുപക്ഷേ "@{[ സിസ്റ്റം "rm -rf /" ]}" പോലെയുള്ള എന്തെങ്കിലും, അപ്പോൾ എനിക്ക് എന്നെത്തന്നെ ഉൾപ്പെടുത്താം
കുഴപ്പം.

സുരക്ഷാ പ്രശ്‌നം പരിഹരിക്കുന്നതിന്, പകരം ഒരു ഹാഷിൽ നിന്ന് മൂല്യങ്ങൾ പിൻവലിക്കാനും എനിക്ക് കഴിയും
വേരിയബിൾ പേരുകൾ വിലയിരുത്തുന്നു. ഒരൊറ്റ "/e" ഉപയോഗിച്ച്, മൂല്യം ഉറപ്പാക്കാൻ എനിക്ക് ഹാഷ് പരിശോധിക്കാം
നിലവിലുണ്ട്, ഇല്ലെങ്കിൽ, ഈ സാഹചര്യത്തിൽ, നഷ്ടപ്പെട്ട മൂല്യത്തെ ഒരു മാർക്കർ ഉപയോഗിച്ച് എനിക്ക് മാറ്റിസ്ഥാപിക്കാം
"???" എനിക്ക് എന്തെങ്കിലും നഷ്ടമായെന്ന് സൂചിപ്പിക്കാൻ:

my $string = 'ഇതിന് $foo ഉം $bar ഉം ഉണ്ട്';

എന്റെ %പകരം = (
foo => 'ഫ്രെഡ്',
);

# $string =~ s/\$(\w+)/$Replacements{$1}/g;
$string =~ s/\$(\w+)/
$Replacements{$1} നിലവിലുണ്ടോ? $Replacements{$1} : '???'
/ഉദാ;

$ സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യുക;

എന്താണ് തെറ്റ് കൂടെ എല്ലായിപ്പോഴും ഉദ്ധരിക്കുന്നു "$vars"?
ആ ഇരട്ട ഉദ്ധരണികൾ സ്ട്രിംഗ്ഫിക്കേഷനെ നിർബന്ധിക്കുന്നു എന്നതാണ് പ്രശ്നം - നിർബന്ധിത സംഖ്യകൾ ഒപ്പം
സ്ട്രിംഗുകളിലേക്കുള്ള റഫറൻസുകൾ - അവ സ്ട്രിംഗുകളാകാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിലും. ഇത് ചിന്തിക്കുക
വഴി: പുതിയ സ്ട്രിംഗുകൾ നിർമ്മിക്കാൻ ഇരട്ട ഉദ്ധരണി വിപുലീകരണം ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് ഇതിനകം ഒരു സ്ട്രിംഗ് ഉണ്ടെങ്കിൽ,
എന്തുകൊണ്ടാണ് നിങ്ങൾക്ക് കൂടുതൽ വേണ്ടത്?

ഇതുപോലുള്ള വിചിത്രമായ കാര്യങ്ങൾ എഴുതാൻ നിങ്ങൾ ശീലിച്ചാൽ:

"$var" അച്ചടിക്കുക; # മോശം
എന്റെ $പുതിയ = "$പഴയ"; # മോശം
somefunc("$var"); # മോശം

നിങ്ങൾ കുഴപ്പത്തിലാകും. അവ (99.8% കേസുകളിലും) ലളിതവും കൂടുതൽ നേരിട്ടുള്ളതുമായിരിക്കണം:

$var അച്ചടിക്കുക;
എന്റെ $പുതിയ = $പഴയ;
somefunc($var);

അല്ലാത്തപക്ഷം, നിങ്ങളെ മന്ദഗതിയിലാക്കുന്നതിനു പുറമേ, കാര്യം വരുമ്പോൾ നിങ്ങൾ കോഡ് തകർക്കാൻ പോകുകയാണ്
സ്കെയിലർ യഥാർത്ഥത്തിൽ ഒരു സ്ട്രിംഗോ സംഖ്യയോ അല്ല, ഒരു റഫറൻസ് ആണ്:

func (\@array);
സബ് ഫംഗ് {
എന്റെ $ആരെഫ് = ഷിഫ്റ്റ്;
എന്റെ $oref = "$aref"; # തെറ്റ്
}

യഥാർത്ഥത്തിൽ ചെയ്യുന്ന Perl-ലെ ചില പ്രവർത്തനങ്ങളിൽ നിങ്ങൾക്ക് സൂക്ഷ്മമായ പ്രശ്‌നങ്ങൾ നേരിടാം
മാന്ത്രിക "++" പോലെയുള്ള ഒരു സ്ട്രിംഗും സംഖ്യയും തമ്മിലുള്ള വ്യത്യാസം ശ്രദ്ധിക്കുക
ഓട്ടോഇൻക്രിമെന്റ് ഓപ്പറേറ്റർ അല്ലെങ്കിൽ syscal() പ്രവർത്തനം.

സ്ട്രിംഗ്ഫിക്കേഷൻ അറേകളെയും നശിപ്പിക്കുന്നു.

എന്റെ @ലൈനുകൾ = `കമാൻഡ്`;
"@ലൈനുകൾ" പ്രിന്റ് ചെയ്യുക; # തെറ്റ് - അധിക ശൂന്യത
@ലൈനുകൾ പ്രിന്റ് ചെയ്യുക; # ശരിയാണ്

എന്തുകൊണ്ട് ചെയ്യരുത് my < പ്രമാണങ്ങൾ പ്രവർത്തിക്കും?
ഇവിടെ രേഖകൾ പെർലോപ്പിൽ കാണാം. ഈ മൂന്ന് കാര്യങ്ങൾ പരിശോധിക്കുക:

<< ഭാഗത്തിന് ശേഷം ഇടം ഉണ്ടാകരുത്.
ഓപ്പണിംഗ് ടോക്കണിന്റെ അവസാനം (ഒരുപക്ഷേ) ഒരു അർദ്ധവിരാമം ഉണ്ടായിരിക്കണം
ടാഗിന് മുന്നിൽ നിങ്ങൾക്ക് (എളുപ്പത്തിൽ) ഇടം നൽകാനാവില്ല.
എൻഡ് ടോക്കണിന് ശേഷം കുറഞ്ഞത് ഒരു ലൈൻ സെപ്പറേറ്റർ എങ്കിലും ഉണ്ടായിരിക്കണം.

ഇവിടെയുള്ള പ്രമാണത്തിലെ വാചകം ഇൻഡന്റ് ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് ഇത് ചെയ്യാം:

# എല്ലാം ഒന്നിൽ
(എന്റെ $VAR = <
നിങ്ങളുടെ വാചകം
ഇവിടെ പോകുന്നു
ഇവിടെ_TARGET

എന്നാൽ HERE_TARGET ഇപ്പോഴും മാർജിനിനെതിരെ ഫ്ലഷ് ആയിരിക്കണം. നിങ്ങൾക്ക് അത് ഇൻഡന്റ് ചെയ്യണമെങ്കിൽ
കൂടാതെ, നിങ്ങൾ ഇൻഡന്റേഷനിൽ ഉദ്ധരിക്കേണ്ടി വരും.

(എന്റെ $quote = <<' FINIS') =~ s/^\s+//gm;
നിനക്കും നിന്റെ എല്ലാ പ്രവൃത്തികൾക്കും ഉള്ളപ്പോൾ ഞങ്ങൾക്കു സമാധാനം ഉണ്ടാകും
നശിച്ചു--നിങ്ങളുടെ ഇരുണ്ട യജമാനന്റെ പ്രവൃത്തികളും നിങ്ങൾ ആർക്കാണ്
ഞങ്ങളെ ഏല്പിക്കും. നിങ്ങൾ ഒരു നുണയനാണ്, സാറുമാൻ, അഴിമതിക്കാരനാണ്
പുരുഷന്മാരുടെ ഹൃദയങ്ങളുടെ. --Theoden in /usr/src/perl/taint.c
ഫിനിസ്
$quote =~ s/\s+--/\n--/;

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

ഉപ പരിഹാരം {
പ്രാദേശിക $_ = ഷിഫ്റ്റ്;
എന്റെ ($ വെള്ള, $ ലീഡർ); # കോമൺ വൈറ്റ്‌സ്‌പെയ്‌സും കോമൺ ലീഡിംഗ് സ്‌ട്രിംഗും
എങ്കിൽ (/^\s*(?:([^\w\s]+)(\s*).*\n)(?:\s*\g1\g2?.*\n)+$/) {
($വൈറ്റ്, $ ലീഡർ) = ($2, quotemeta($1));
} else {
($വൈറ്റ്, $ ലീഡർ) = (/^(\s+)/, '');
}
s/^\s*?$leader(?:$white)?//gm;
തിരികെ $_;
}

ഇത് മുൻനിര പ്രത്യേക സ്ട്രിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു, ചലനാത്മകമായി നിർണ്ണയിക്കപ്പെടുന്നു:

എന്റെ $remember_the_main = പരിഹരിക്കുക<<' MAIN_INTERPRETER_LOOP';
@@@ int
@@@ റണ്ണോപ്പുകൾ() {
@@@ SAVEI32(റൺലെവൽ);
@@@ റൺലെവൽ++;
@@@ സമയത്ത് (op = (*op->op_ppaddr)() );
@@@ TAINT_NOT;
@@@ റിട്ടേൺ 0;
@@@}
MAIN_INTERPRETER_LOOP

അല്ലെങ്കിൽ ഒരു നിശ്ചിത അളവിൽ ലീഡിംഗ് വൈറ്റ്‌സ്‌പെയ്‌സ്, ശേഷിക്കുന്ന ഇൻഡന്റേഷൻ ശരിയായി
സംരക്ഷിച്ചു:

എന്റെ $കവിത = പരിഹരിക്കുക<
ഇപ്പോൾ റോഡ് വളരെ മുന്നോട്ട് പോയി,
എനിക്ക് കഴിയുമെങ്കിൽ ഞാൻ പിന്തുടരണം,
ആകാംക്ഷയോടെ അതിനെ പിന്തുടരുന്നു,
അത് വലിയ രീതിയിൽ ചേരുന്നത് വരെ
പല വഴികളും കർത്തവ്യങ്ങളും സംഗമിക്കുന്നിടത്ത്.
പിന്നെ എവിടെ? എനിക്ക് പറയാൻ പറ്റില്ല.
--Bilbo in /usr/src/perl/pp_ctl.c
EVER_ON_AND_ON

ഡാറ്റ: അറേ

എന്ത് is The വ്യത്യാസം തമ്മിലുള്ള a പട്ടിക ഒപ്പം an അറേ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

സ്കെയിലറുകളുടെ ഒരു നിശ്ചിത ശേഖരമാണ് ലിസ്റ്റ്. ഒരു വേരിയബിൾ കൈവശമുള്ള ഒരു വേരിയബിളാണ് അറേ
സ്കെയിലറുകളുടെ ശേഖരം. ലിസ്റ്റ് പ്രവർത്തനങ്ങൾക്കായി ഒരു അറേയ്ക്ക് അതിന്റെ ശേഖരം നൽകാൻ കഴിയും, അതിനാൽ ലിസ്റ്റ് ചെയ്യുക
പ്രവർത്തനങ്ങൾ അറേകളിലും പ്രവർത്തിക്കുന്നു:

# കഷ്ണങ്ങൾ
('നായ', 'പൂച്ച', 'പക്ഷി' )[2,3];
@മൃഗങ്ങൾ[2,3];

# ആവർത്തനം
foreach (qw( നായ പൂച്ച പക്ഷി ) ) { ...}
ഫോറെച്ച് (@മൃഗങ്ങൾ) {...}

എന്റെ @മൂന്ന് = grep {നീളം == 3 } qw( നായ പൂച്ച പക്ഷി );
എന്റെ @മൂന്ന് = ഗ്രെപ് {നീളം == 3 } @മൃഗങ്ങൾ;

# ഒരു ആർഗ്യുമെന്റ് ലിസ്റ്റ് നൽകുക
വാഷ്_അനിമൽസ് (ക്യുഡബ്ല്യു (പട്ടി പൂച്ച പക്ഷി) );
വാഷ്_അനിമൽസ്( @മൃഗങ്ങൾ );

സ്കെയിലറുകൾ മാറ്റുകയോ പുനഃക്രമീകരിക്കുകയോ ചിലത് ചേർക്കുകയോ കുറയ്ക്കുകയോ ചെയ്യുന്ന അറേ പ്രവർത്തനങ്ങൾ
സ്കെയിലറുകൾ, അറേകളിൽ മാത്രം പ്രവർത്തിക്കുന്നു. സ്ഥിരമായ ഒരു ലിസ്റ്റിൽ ഇവ പ്രവർത്തിക്കില്ല. അറേ പ്രവർത്തനങ്ങൾ
"ഷിഫ്റ്റ്", "അൺഷിഫ്റ്റ്", "പുഷ്", "പോപ്പ്", "സ്പ്ലൈസ്" എന്നിവ ഉൾപ്പെടുന്നു.

ഒരു അറേയ്ക്ക് അതിന്റെ നീളം മാറ്റാനും കഴിയും:

$#മൃഗങ്ങൾ = 1; # രണ്ട് ഘടകങ്ങളിലേക്ക് ചുരുക്കുക
$#മൃഗങ്ങൾ = 10000; # 10,001 ഘടകങ്ങളിലേക്ക് മുൻകൂട്ടി നീട്ടുക

നിങ്ങൾക്ക് ഒരു അറേ ഘടകം മാറ്റാൻ കഴിയും, എന്നാൽ നിങ്ങൾക്ക് ഒരു ലിസ്റ്റ് ഘടകം മാറ്റാൻ കഴിയില്ല:

$അനിമൽസ്[0] = 'റോട്ട്‌വീലർ';
qw(നായ പൂച്ച പക്ഷി )[0] = 'റോട്ട്‌വീലർ'; # വാക്യഘടന പിശക്!

ഫോറെച്ച് (@മൃഗങ്ങൾ) {
s/^d/fr/; # നന്നായി പ്രവർത്തിക്കുന്നു
}

ഫോറെച്ച് (ക്യുഡബ്ല്യു(പട്ടി പൂച്ച പക്ഷി)) {
s/^d/fr/; #പിശക്! വായിക്കാൻ മാത്രമുള്ള മൂല്യത്തിന്റെ പരിഷ്ക്കരണം!
}

എന്നിരുന്നാലും, ലിസ്റ്റ് ഘടകം തന്നെ ഒരു വേരിയബിൾ ആണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ലിസ്റ്റ് മാറ്റാൻ കഴിയുമെന്ന് തോന്നുന്നു
ഘടകം. എന്നിരുന്നാലും, ലിസ്റ്റ് ഘടകം വേരിയബിളാണ്, ഡാറ്റയല്ല. നിങ്ങൾ മാറ്റുന്നില്ല
ലിസ്റ്റ് ഘടകം, എന്നാൽ ലിസ്റ്റ് ഘടകം സൂചിപ്പിക്കുന്നത്. ലിസ്റ്റ് ഘടകം തന്നെ ഇല്ല
മാറ്റം: അത് ഇപ്പോഴും അതേ വേരിയബിളാണ്.

സന്ദർഭത്തിലും നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്. നിങ്ങൾക്ക് ഒരു സ്കെയിലറിലേക്ക് ഒരു അറേ നൽകാം
അറേയിലെ മൂലകങ്ങളുടെ എണ്ണം. ഇത് അറേകൾക്ക് മാത്രമേ പ്രവർത്തിക്കൂ, എന്നിരുന്നാലും:

എന്റെ $എണ്ണം = @മൃഗങ്ങൾ; # അറേകളിൽ മാത്രം പ്രവർത്തിക്കുന്നു

ഒരു ലിസ്റ്റ് എന്ന് നിങ്ങൾ കരുതുന്ന അതേ കാര്യം തന്നെ ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് തികച്ചും വ്യത്യസ്തമായ ഒന്ന് ലഭിക്കും
ഫലമായി. നിങ്ങൾക്ക് വലതുവശത്ത് ഒരു ലിസ്റ്റ് ഉണ്ടെന്ന് തോന്നുന്നുവെങ്കിലും, യഥാർത്ഥത്തിൽ പേൾ എ കാണുന്നു
ഒരു കൂട്ടം സ്കെയിലറുകൾ കോമയാൽ വേർതിരിച്ചിരിക്കുന്നു:

എന്റെ $ സ്കെയിലർ = ('നായ', 'പൂച്ച', 'പക്ഷി' ); # $scalar പക്ഷിയെ നേടുന്നു

നിങ്ങൾ ഒരു സ്കെയിലറിലേക്ക് അസൈൻ ചെയ്യുന്നതിനാൽ, വലതുഭാഗം സ്കെയിലർ സന്ദർഭത്തിലാണ്. കോമ
ഓപ്പറേറ്റർ (അതെ, ഇത് ഒരു ഓപ്പറേറ്ററാണ്!) സ്കെയിലർ സന്ദർഭത്തിൽ അതിന്റെ ഇടത് വശം വിലയിരുത്തുന്നു, എറിയുന്നു
ഫലം മാറ്റി, അതിന്റെ വലതുവശം വിലയിരുത്തി ഫലം നൽകുന്നു. ഫലത്തിൽ, അത്
list-lookalike $scalar-ലേക്ക് അസൈൻ ചെയ്യുന്നു അതിന്റെ ഏറ്റവും വലത് മൂല്യം. പലരും ഇത് കുഴപ്പത്തിലാക്കുന്നു, കാരണം
അവർ ഒരു ലിസ്റ്റ്-രൂപം തിരഞ്ഞെടുക്കുന്നു, അതിന്റെ അവസാന ഘടകവും അവർ പ്രതീക്ഷിക്കുന്ന എണ്ണമാണ്:

എന്റെ $ സ്കെയിലർ = ( 1, 2, 3 ); # $scalar-ന് ആകസ്മികമായി 3 ലഭിക്കുന്നു

എന്ത് is The വ്യത്യാസം തമ്മിലുള്ള $array[1] ഒപ്പം @അറേ[1]?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

വ്യത്യാസം സിഗിൽ ആണ്, അറേ പേരിന് മുന്നിലുള്ള പ്രത്യേക പ്രതീകം. "$"
sigil എന്നാൽ "കൃത്യമായി ഒരു ഇനം" എന്നാണ് അർത്ഥമാക്കുന്നത്, അതേസമയം "@" സിഗിൽ എന്നാൽ "പൂജ്യം അല്ലെങ്കിൽ കൂടുതൽ ഇനങ്ങൾ" എന്നാണ്. "$"
നിങ്ങൾക്ക് ഒരൊറ്റ സ്കെയിലർ ലഭിക്കും, അതേസമയം "@" നിങ്ങൾക്ക് ഒരു ലിസ്റ്റ് ലഭിക്കും.

സിഗിൽ വേരിയബിളിനെ സൂചിപ്പിക്കുന്നുവെന്ന് ആളുകൾ തെറ്റായി അനുമാനിക്കുന്നതിനാലാണ് ആശയക്കുഴപ്പം ഉണ്ടാകുന്നത്.
ടൈപ്പ് ചെയ്യുക.

$array[1] എന്നത് അറേയിലേക്കുള്ള ഒരു ഒറ്റമൂലക ആക്‌സസ് ആണ്. അത് ഇനം തിരികെ നൽകാൻ പോകുന്നു
സൂചിക 1 (അല്ലെങ്കിൽ ഒരു ഇനവും ഇല്ലെങ്കിൽ undef). നിങ്ങൾ കൃത്യമായി ഒരു ഘടകം ലഭിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
അറേയിൽ നിന്ന്, നിങ്ങൾ ഉപയോഗിക്കേണ്ട ഫോം ഇതാണ്.

@array[1] എന്നത് ഒരു അറേ സ്ലൈസാണ്, എന്നിരുന്നാലും ഇതിന് ഒരു സൂചിക മാത്രമേയുള്ളൂ. നിങ്ങൾക്ക് പുറത്തെടുക്കാം
അധിക സൂചികകൾ ഒരു ലിസ്‌റ്റായി വ്യക്തമാക്കുന്നതിലൂടെ ഒരേസമയം ഒന്നിലധികം ഘടകങ്ങൾ
@അറേ[1,4,3,0].

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

$array[1] = ;

എന്നിരുന്നാലും, ലിസ്റ്റ് സന്ദർഭത്തിൽ, ലൈൻ ഇൻപുട്ട് ഓപ്പറേറ്റർ എല്ലാ ലൈനുകളും ഒരു ലിസ്റ്റായി നൽകുന്നു. ദി
ആദ്യ വരി @array[1] ലേക്ക് പോകുന്നു, ബാക്കി വരികൾ നിഗൂഢമായി അപ്രത്യക്ഷമാകുന്നു:

@അറേ[1] = ; # മിക്കവാറും നിങ്ങൾ ആഗ്രഹിക്കുന്നതല്ല

ഒന്നുകിൽ "ഉപയോഗ മുന്നറിയിപ്പ്" പ്രാഗ്മ അല്ലെങ്കിൽ -w നിങ്ങൾ ഒരു അറേ സ്ലൈസ് ഉപയോഗിക്കുമ്പോൾ ഫ്ലാഗ് നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകും
ഒരൊറ്റ സൂചിക ഉപയോഗിച്ച്.

എങ്ങനെ കഴിയും I നീക്കം പകര്പ്പ് ഘടകങ്ങൾ നിന്ന് a പട്ടിക or അറേ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഒരു ഹാഷ് ഉപയോഗിക്കുക. "അദ്വിതീയം" അല്ലെങ്കിൽ "ഡ്യൂപ്ലിക്കേറ്റ്" എന്ന വാക്കുകൾ നിങ്ങൾ ചിന്തിക്കുമ്പോൾ, "ഹാഷ് കീകൾ" എന്ന് ചിന്തിക്കുക.

മൂലകങ്ങളുടെ ക്രമം നിങ്ങൾ ശ്രദ്ധിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് ഹാഷ് സൃഷ്‌ടിക്കാം
കീകൾ വേർതിരിച്ചെടുക്കുക. നിങ്ങൾ ആ ഹാഷ് എങ്ങനെ സൃഷ്ടിക്കുന്നു എന്നത് പ്രധാനമല്ല: നിങ്ങൾ "കീകൾ" ഉപയോഗിക്കുന്നു
അതുല്യമായ ഘടകങ്ങൾ നേടുക.

എന്റെ %hash = മാപ്പ് {$_, 1 } @array;
# അല്ലെങ്കിൽ ഒരു ഹാഷ് സ്ലൈസ്: @hash{ @array } = ();
# അല്ലെങ്കിൽ ഒരു ഫോർച്ച്: $hash{$_} = 1 foreach (@array );

my @unique = കീകൾ %hash;

നിങ്ങൾക്ക് ഒരു മൊഡ്യൂൾ ഉപയോഗിക്കണമെങ്കിൽ, List ::MoreUtils-ൽ നിന്ന് "uniq" ഫംഗ്‌ഷൻ പരീക്ഷിക്കുക. പട്ടിക സന്ദർഭത്തിൽ
ഇത് തനതായ ഘടകങ്ങൾ തിരികെ നൽകുന്നു, പട്ടികയിൽ അവയുടെ ക്രമം സംരക്ഷിക്കുന്നു. സ്കെയിലർ സന്ദർഭത്തിൽ, അത്
അദ്വിതീയ ഘടകങ്ങളുടെ എണ്ണം നൽകുന്നു.

ലിസ്റ്റ് ഉപയോഗിക്കുക ::MoreUtils qw(uniq);

my @unique = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 1,2,3,4,5,6,7
എന്റെ $അതുല്യം = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 7

നിങ്ങൾക്ക് ഓരോ ഘടകങ്ങളിലൂടെയും പോയി നിങ്ങൾ മുമ്പ് കണ്ടവ ഒഴിവാക്കാനും കഴിയും. ഇതിനായി ഒരു ഹാഷ് ഉപയോഗിക്കുക
ട്രാക്ക് സൂക്ഷിക്കുക. ലൂപ്പ് ആദ്യമായി ഒരു മൂലകം കാണുമ്പോൾ, ആ മൂലകത്തിന് %Seen-ൽ കീ ഇല്ല. ദി
"next" പ്രസ്താവന കീ സൃഷ്ടിക്കുകയും ഉടൻ തന്നെ അതിന്റെ മൂല്യം ഉപയോഗിക്കുകയും ചെയ്യുന്നു, അത് "undef" ആണ്, അതിനാൽ
ലൂപ്പ് "പുഷ്" ആയി തുടരുകയും ആ കീയുടെ മൂല്യം വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു. അടുത്ത തവണ ലൂപ്പ്
അതേ ഘടകം കാണുന്നു, അതിന്റെ കീ ഹാഷിൽ നിലവിലുണ്ട് ഒപ്പം ആ കീയുടെ മൂല്യം ശരിയാണ്
(ഇത് 0 അല്ലെങ്കിൽ "undef" അല്ലാത്തതിനാൽ), അടുത്തത് ആ ആവർത്തനം ഒഴിവാക്കുകയും ലൂപ്പ് ഇതിലേക്ക് പോകുകയും ചെയ്യുന്നു
അടുത്ത ഘടകം.

എന്റെ @തനത് = ();
എന്റെ %സീൻ = ();

എന്റെ $elem (@array ) {
അടുത്തത് $ കണ്ടാൽ{ $elem }++;
പുഷ് @അതുല്യം, $elem;
}

ഇതേ കാര്യം ചെയ്യുന്ന ഒരു grep ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് കൂടുതൽ ചുരുക്കി എഴുതാം.

എന്റെ %സീൻ = ();
my @unique = grep {! $seen{ $_ }++ } @array;

എങ്ങനെ കഴിയും I പറയൂ എന്ന് a ചിലത് മൂലകം is അടങ്ങിയിരിക്കുന്നു in a പട്ടിക or അറേ?
(ഈ ഉത്തരത്തിന്റെ ഭാഗങ്ങൾ അന്നോ സീഗലും ബ്രയാൻ ഡി ഫോയും സംഭാവന ചെയ്തു)

"ഇൻ" എന്ന വാക്ക് കേൾക്കുന്നത് ഒരു ആണ് inനിങ്ങൾ ഒരുപക്ഷേ ഒരു ഹാഷ് ഉപയോഗിക്കേണ്ടതായിരുന്നു, ഒരു അല്ല
നിങ്ങളുടെ ഡാറ്റ സംഭരിക്കുന്നതിന് ലിസ്റ്റ് അല്ലെങ്കിൽ അറേ. ഈ ചോദ്യത്തിന് വേഗത്തിൽ ഉത്തരം നൽകുന്നതിനാണ് ഹാഷുകൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്
കാര്യക്ഷമമായി. അറേകൾ അല്ല.

പറഞ്ഞുവരുന്നത്, ഇതിനെ സമീപിക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്. Perl 5.10-ലും അതിനുശേഷവും, നിങ്ങൾക്ക് കഴിയും
ഒരു ഇനം ഒരു അറേയിലോ ഹാഷിലോ അടങ്ങിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കാൻ സ്മാർട്ട് മാച്ച് ഓപ്പറേറ്റർ ഉപയോഗിക്കുക:

5.010 ഉപയോഗിക്കുക;

എങ്കിൽ ($ഇനം ~~ @array ) {
"അറേയിൽ $ഇനം അടങ്ങിയിരിക്കുന്നു" എന്ന് പറയുക
}

എങ്കിൽ ($ഇനം ~~ %ഹാഷ്) {
"ഹാഷിൽ $ഇനം അടങ്ങിയിരിക്കുന്നു" എന്ന് പറയുക
}

Perl-ന്റെ മുൻ പതിപ്പുകൾക്കൊപ്പം, നിങ്ങൾ കുറച്ചുകൂടി പ്രവർത്തിക്കേണ്ടതുണ്ട്. നിങ്ങൾ ഉണ്ടാക്കാൻ പോകുകയാണെങ്കിൽ
ഈ ചോദ്യം അനിയന്ത്രിതമായ സ്ട്രിംഗ് മൂല്യങ്ങളിൽ പലതവണ, വിപരീതമാക്കുക എന്നതാണ് ഏറ്റവും വേഗതയേറിയ മാർഗം
ഒറിജിനൽ അറേയും ഒരു ഹാഷും നിലനിർത്തുക, അതിന്റെ കീകൾ ആദ്യ അറേയുടെ മൂല്യങ്ങളാണ്:

എന്റെ @ബ്ലൂസ് = qw/അസുർ സെറൂലിയൻ ടീൽ ടർക്കോയ്സ് ലാപിസ്-ലാസുലി/;
എന്റെ %is_blue = ();
വേണ്ടി (@blues) {$is_blue{$_} = 1 }

$is_blue{$some_color} ആണോ എന്ന് ഇപ്പോൾ നിങ്ങൾക്ക് പരിശോധിക്കാം. അത് സൂക്ഷിക്കുന്നത് നല്ല ആശയമായിരുന്നിരിക്കാം
ബ്ലൂസ് എല്ലാം ആദ്യം ഒരു ഹാഷിൽ.

മൂല്യങ്ങളെല്ലാം ചെറിയ പൂർണ്ണസംഖ്യകളാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ലളിതമായ സൂചികയിലുള്ള അറേ ഉപയോഗിക്കാം. ഇത്തരത്തിലുള്ള
ഒരു അറേ കുറച്ച് സ്ഥലം എടുക്കും:

എന്റെ @പ്രൈമുകൾ = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31);
എന്റെ @is_tiny_prime = ();
(@primes) {$is_tiny_prime[$_] = 1 }
# അല്ലെങ്കിൽ ലളിതമായി @istiny_prime[@primes] = (1) x @primes;

ഇപ്പോൾ നിങ്ങൾ $is_tiny_prime[$some_number] എന്ന് പരിശോധിക്കുക.

പ്രസ്തുത മൂല്യങ്ങൾ സ്ട്രിംഗുകൾക്ക് പകരം പൂർണ്ണസംഖ്യകളാണെങ്കിൽ, നിങ്ങൾക്ക് ധാരാളം ലാഭിക്കാൻ കഴിയും
പകരം ബിറ്റ് സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് ഇടം:

എന്റെ @ലേഖനങ്ങൾ = (1..10, 150..2000, 2017 );
undef $ വായിക്കുക;
(@ലേഖനങ്ങൾ) {vec($read,$_,1) = 1 }

ചില $n ന് "vec($read,$n,1)" ശരിയാണോ എന്ന് ഇപ്പോൾ പരിശോധിക്കുക.

ഈ രീതികൾ വേഗത്തിലുള്ള വ്യക്തിഗത പരിശോധനകൾക്ക് ഉറപ്പുനൽകുന്നു, എന്നാൽ ഒരു പുനഃസംഘടന ആവശ്യമാണ്
യഥാർത്ഥ ലിസ്റ്റ് അല്ലെങ്കിൽ അറേ. ഒന്നിലധികം മൂല്യങ്ങൾ പരീക്ഷിക്കേണ്ടിവന്നാൽ മാത്രമേ അവ ഫലം നൽകൂ
ഒരേ അറേ.

നിങ്ങൾ ഒരു തവണ മാത്രമേ പരീക്ഷിക്കുന്നുള്ളൂ എങ്കിൽ, സ്റ്റാൻഡേർഡ് മൊഡ്യൂൾ ലിസ്റ്റ് ::Util "ആദ്യം" എന്ന ഫംഗ്‌ഷൻ എക്‌സ്‌പോർട്ട് ചെയ്യുന്നു
ഈ ആവശ്യത്തിനായി. മൂലകം കണ്ടെത്തിക്കഴിഞ്ഞാൽ അത് നിർത്തിയാൽ പ്രവർത്തിക്കുന്നു. സി ഫോർ എന്ന അക്ഷരത്തിലാണ് എഴുതിയിരിക്കുന്നത്
വേഗത, അതിന്റെ പേൾ തുല്യമായത് ഈ സബ്റൂട്ടീൻ പോലെയാണ്:

ഉപ ആദ്യം (&@) {
എന്റെ $ കോഡ് = ഷിഫ്റ്റ്;
ഫോറെച്ച് (@_) {
&{$code}() എങ്കിൽ $_ തിരികെ നൽകുക;
}
undef;
}

വേഗത കാര്യമാക്കേണ്ടതില്ലെങ്കിൽ, സ്കെയിലർ സന്ദർഭത്തിൽ ഗ്രെപ്പ് ഉപയോഗിക്കുന്നു (ഇത് തിരികെ നൽകുന്നു
മുഴുവൻ ലിസ്റ്റിലും സഞ്ചരിക്കാൻ അതിന്റെ വ്യവസ്ഥ മറികടന്ന ഇനങ്ങളുടെ എണ്ണം. ഇതിന് ഉണ്ട്
എന്നിരുന്നാലും, അത് എത്ര പൊരുത്തങ്ങൾ കണ്ടെത്തി എന്ന് നിങ്ങളോട് പറയുന്നതിന്റെ പ്രയോജനം.

എന്റെ $ is_there = grep $_ eq $ എന്തായാലും, @array;

നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ പൊരുത്തപ്പെടുന്ന ഘടകങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യണമെങ്കിൽ, ലിസ്റ്റ് സന്ദർഭത്തിൽ grep ഉപയോഗിക്കുക.

എന്റെ @മത്സരങ്ങൾ = grep $_ eq $ എന്തായാലും, @array;

എങ്ങനെ do I കണക്കാക്കുക The വ്യത്യാസം of രണ്ട് അറേകൾ? എങ്ങനെ do I കണക്കാക്കുക The വിഭജനം of രണ്ട്
അറേകൾ?
ഒരു ഹാഷ് ഉപയോഗിക്കുക. രണ്ടും അതിലധികവും ചെയ്യാനുള്ള കോഡ് ഇതാ. ഓരോ മൂലകവും a യിൽ അദ്വിതീയമാണെന്ന് ഇത് അനുമാനിക്കുന്നു
നൽകിയിരിക്കുന്ന ശ്രേണി:

എന്റെ (@യൂണിയൻ, @കവല, @വ്യത്യാസം);
എന്റെ % എണ്ണം = ();
എന്റെ $എലമെന്റ് (@array1, @array2) {$count{$element}++} നേടുക
എന്റെ $എലമെന്റിനെ സമീപിക്കുക (കീകളുടെ %എണ്ണം) {
പുഷ് @ യൂണിയൻ, $ എലമെന്റ്;
@{ $count{$element} > 1 പുഷ്? \@ഇന്റർസെക്ഷൻ : \@വ്യത്യാസം}, ​​$മൂലകം;
}

ഇതാണ് എന്നത് ശ്രദ്ധിക്കുക സമമിതി വ്യത്യാസം, അതായത്, എയിലോ ബിയിലോ ഉള്ള എല്ലാ ഘടകങ്ങളും
രണ്ടിലും ഇല്ല. ഇതൊരു xor ഓപ്പറേഷനായി കരുതുക.

എങ്ങനെ do I പരിശോധന എന്ന് രണ്ട് ശ്രേണികൾ or ഹാഷുകൾ ആകുന്നു തുല്യമോ?
Perl 5.10-ഉം അതിനുശേഷമുള്ള പതിപ്പുകളും ഉപയോഗിച്ച്, സ്‌മാർട്ട് മാച്ച് ഓപ്പറേറ്റർക്ക് നിങ്ങൾക്ക് ഉത്തരം നൽകാൻ കഴിയും
ജോലിയുടെ അളവ്:

5.010 ഉപയോഗിക്കുക;

എങ്കിൽ(@array1 ~~ @array2 ) {
"അറേകൾ ഒന്നുതന്നെയാണ്" എന്ന് പറയുക;
}

if( %hash1 ~~ %hash2 ) # മൂല്യങ്ങൾ പരിശോധിക്കുന്നില്ല! {
"ഹാഷ് കീകൾ ഒന്നുതന്നെയാണ്" എന്ന് പറയുക;
}

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

$are_equal = compare_arrays(\@frogs, \@toads);

ഉപ compare_arrays {
എന്റെ ($ആദ്യം, $സെക്കൻഡ്) = @_;
മുന്നറിയിപ്പുകളില്ല; # നിശബ്ദത വ്യാജമായ -w undef പരാതികൾ
@$first == @$second അല്ലാതെ 0 തിരികെ നൽകുക;
ഇതിനായി (എന്റെ $i = 0; $i < @$first; $i++) {
$first->[$i] ne $second->[$i] ആണെങ്കിൽ 0 തിരികെ നൽകുക;
}
തിരികെ വരുക;
}

മൾട്ടി ലെവൽ ഘടനകൾക്കായി, ഇതുപോലുള്ള ഒരു സമീപനം ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഇത് ഉപയോഗിക്കുന്നു
CPAN മൊഡ്യൂൾ FreezeThaw:

FreezeThaw qw(cmpStr) ഉപയോഗിക്കുക;
my @a = my @b = ( "ഇത്", "അത്", [ "കൂടുതൽ", "സാധനങ്ങൾ" ] );

printf "a, b എന്നിവയിൽ %s അറേകൾ അടങ്ങിയിരിക്കുന്നു\n",
cmpStr(\@a, \@b) == 0
? "അതുതന്നെ"
: "വ്യത്യസ്ത";

ഹാഷുകൾ താരതമ്യം ചെയ്യുന്നതിനും ഈ സമീപനം പ്രവർത്തിക്കുന്നു. ഇവിടെ നമ്മൾ രണ്ട് വ്യത്യസ്തത കാണിക്കും
ഉത്തരങ്ങൾ:

FreezeThaw qw(cmpStr cmpStrHard) ഉപയോഗിക്കുക;

എന്റെ %a = എന്റെ %b = ( "ഇത്" => "അത്", "അധിക" => [ "കൂടുതൽ", "സാധനങ്ങൾ" ] );
$a{EXTRA} = \%b;
$b{EXTRA} = \%a;

printf "a, b എന്നിവയിൽ %s ഹാഷുകൾ അടങ്ങിയിരിക്കുന്നു\n",
cmpStr(\%a, \%b) == 0 ? "അതേ" : "വ്യത്യസ്തമായത്";

printf "a, b എന്നിവയിൽ %s ഹാഷുകൾ അടങ്ങിയിരിക്കുന്നു\n",
cmpStrHard(\%a, \%b) == 0 ? "അതേ" : "വ്യത്യസ്തമായത്";

ആ രണ്ട് ഹാഷുകളിലും ഒരേ ഡാറ്റ അടങ്ങിയിരിക്കുന്നുവെന്ന് ആദ്യ റിപ്പോർട്ടുകൾ, രണ്ടാമത്തേത്
ഇല്ലെന്നാണ് റിപ്പോർട്ട്. നിങ്ങൾ ഇഷ്ടപ്പെടുന്നത് വായനക്കാരന് ഒരു വ്യായാമമായി അവശേഷിക്കുന്നു.

എങ്ങനെ do I കണ്ടെത്തുക The ആദ്യം ശ്രേണി മൂലകം വേണ്ടി ഏത് a കണ്ടീഷൻ is ശരിയാണോ?
ഒരു വ്യവസ്ഥയെ തൃപ്തിപ്പെടുത്തുന്ന ആദ്യ അറേ ഘടകം കണ്ടെത്താൻ, നിങ്ങൾക്ക് "ആദ്യം()" ഉപയോഗിക്കാം
Perl 5.8-നൊപ്പം വരുന്ന List ::Util മൊഡ്യൂളിലെ പ്രവർത്തനം. ഈ ഉദാഹരണം ആദ്യത്തേത് കണ്ടെത്തുന്നു
"Perl" അടങ്ങിയിരിക്കുന്ന ഘടകം.

ലിസ്റ്റ് ഉപയോഗിക്കുക ::Util qw(ആദ്യം);

എന്റെ $ ഘടകം = ആദ്യത്തെ { /Perl/ } @array;

നിങ്ങൾക്ക് List ::Util ഉപയോഗിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, അതേ കാര്യം ചെയ്യാൻ നിങ്ങൾക്ക് സ്വന്തമായി ലൂപ്പ് ഉണ്ടാക്കാം. ഒരിക്കല് ​​നീ
ഘടകം കണ്ടെത്തുക, അവസാനമായി നിങ്ങൾ ലൂപ്പ് നിർത്തുക.

എന്റെ $ കണ്ടെത്തി;
foreach (@array ) {
if( /Perl/ ) {$found = $_; അവസാനത്തെ }
}

നിങ്ങൾക്ക് അറേ സൂചിക വേണമെങ്കിൽ, "List ::MoreUtils" ൽ നിന്നുള്ള "firstidx()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക:

ലിസ്റ്റ് ഉപയോഗിക്കുക ::MoreUtils qw(firstidx);
എന്റെ $ഇൻഡക്സ് = ഫസ്റ്റ്ഐഡിഎക്സ് { /Perl/ } @array;

അല്ലെങ്കിൽ അത് സ്വയം എഴുതുക, സൂചികകളിലൂടെ ആവർത്തിച്ച് ഓരോന്നിലും അറേ എലമെന്റ് പരിശോധിക്കുക
വ്യവസ്ഥയെ തൃപ്തിപ്പെടുത്തുന്ന ഒന്ന് കണ്ടെത്തുന്നതുവരെ സൂചിക:

എന്റെ ($കണ്ടെത്തുക, $ സൂചിക ) = ( undef, -1 );
ഇതിനായി ($i = 0; $i < @array; $i++ ) {
if( $array[$i] =~ /Perl/ ) {
$ കണ്ടെത്തി = $array[$i];
$ സൂചിക = $ i;
അവസാനത്തെ;
}
}

എങ്ങനെ do I കൈകാര്യം ചെയ്യുക ലിങ്ക്ഡ് ലിസ്റ്റുകൾ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

Perl ന്റെ അറേകൾക്ക് ഒരു നിശ്ചിത വലിപ്പം ഇല്ല, അതിനാൽ നിങ്ങൾക്ക് വേണമെങ്കിൽ ലിങ്ക് ചെയ്ത ലിസ്റ്റുകൾ ആവശ്യമില്ല
ഇനങ്ങൾ ചേർക്കുക അല്ലെങ്കിൽ നീക്കം ചെയ്യുക. നിങ്ങൾക്ക് "പുഷ്", "പോപ്പ്", "ഷിഫ്റ്റ്", തുടങ്ങിയ അറേ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം.
അത് ചെയ്യാൻ "unshift", അല്ലെങ്കിൽ "splice".

എന്നിരുന്നാലും, ചിലപ്പോൾ, ലിങ്കുചെയ്ത ലിസ്‌റ്റുകൾ നിങ്ങൾ "ഷാർഡ്" ചെയ്യാൻ ആഗ്രഹിക്കുന്ന സാഹചര്യങ്ങളിൽ ഉപയോഗപ്രദമാകും
ഒരു വലിയ അറേയ്‌ക്ക് പകരം നിങ്ങൾക്ക് നിരവധി ചെറിയ അറേകളുണ്ട്. നിങ്ങൾക്ക് അറേകൾ സൂക്ഷിക്കാം
Perl-ന്റെ ഏറ്റവും വലിയ അറേ സൂചികയേക്കാൾ ദൈർഘ്യമേറിയതാണ്, ചെറിയ അറേകൾ പ്രത്യേകം ത്രെഡിൽ ലോക്ക് ചെയ്യുക
പ്രോഗ്രാമുകൾ, കുറച്ച് മെമ്മറി വീണ്ടും അനുവദിക്കുക, അല്ലെങ്കിൽ ശൃംഖലയുടെ മധ്യത്തിൽ ഘടകങ്ങൾ വേഗത്തിൽ തിരുകുക.

സ്റ്റീവ് ലെംബാർക്ക് തന്റെ YAPC::NA 2009 സംഭാഷണത്തിലെ "പെർലി ലിങ്ക്ഡ് ലിസ്റ്റുകൾ" (
<http://www.slideshare.net/lembark/perly-linked-lists> ), നിങ്ങൾക്ക് അവന്റെ ഉപയോഗിക്കാൻ കഴിയുമെങ്കിലും
ലിങ്ക്ഡ്‌ലിസ്റ്റ്::ഒറ്റ മൊഡ്യൂൾ.

എങ്ങനെ do I കൈകാര്യം ചെയ്യുക വൃത്താകാരമായ ലിസ്റ്റുകൾ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് അനന്തമായി ഒരു അറേയിലൂടെ സൈക്കിൾ ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് സൂചിക മൊഡ്യൂളോ വർദ്ധിപ്പിക്കാം
അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം:

എന്റെ @അറേ = qw( abc );
എന്റെ $i = 0;

അതേസമയം ( 1 ) {
പ്രിന്റ് $array[ $i++ % @array ], "\n";
അവസാനമെങ്കിൽ $i > 20;
}

എല്ലായ്‌പ്പോഴും എന്നതിന്റെ അടുത്ത ഘടകം ഉള്ള ഒരു സ്‌കെലാർ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾക്ക് ടൈ:: സൈക്കിളും ഉപയോഗിക്കാം
വൃത്താകൃതിയിലുള്ള ശ്രേണി:

ടൈ:: സൈക്കിൾ ഉപയോഗിക്കുക;

ടൈ എന്റെ $സൈക്കിൾ, 'ടൈ::സൈക്കിൾ', [ qw( FFFFFF 000000 FFFF00 ) ];

$ സൈക്കിൾ അച്ചടിക്കുക; # FFFFFF
$ സൈക്കിൾ അച്ചടിക്കുക; # 000000
$ സൈക്കിൾ അച്ചടിക്കുക; # FFFF00

അറേ::Iterator::വൃത്താകൃതിയിലുള്ള അറേകൾക്കായി സർക്കുലർ ഒരു ഇറ്ററേറ്റർ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു:

അറേ:: ഇറ്ററേറ്റർ:: സർക്കുലർ ഉപയോഗിക്കുക;

എന്റെ $color_iterator = അറേ::Iterator::Circular->new(
qw (ചുവപ്പ് പച്ച നീല ഓറഞ്ച്)
);

ഫോറെച്ച് (1 .. 20) {
പ്രിന്റ് $color_iterator->അടുത്തത്, "\n";
}

എങ്ങനെ do I ഷഫിൾ an ശ്രേണി ക്രമരഹിതമായി?
നിങ്ങൾക്ക് ഒന്നുകിൽ Perl 5.8.0 അല്ലെങ്കിൽ പിന്നീട് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് Scalar-List-Utils 1.03 ഉണ്ടെങ്കിൽ അല്ലെങ്കിൽ
പിന്നീട് ഇൻസ്റ്റാൾ ചെയ്തു, നിങ്ങൾക്ക് ഇങ്ങനെ പറയാം:

ലിസ്റ്റ് ഉപയോഗിക്കുക ::ഉട്ടിൽ 'ഷഫിൾ';

@ഷഫിൾഡ് = ഷഫിൾ (@ലിസ്റ്റ്);

ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ഫിഷർ-യേറ്റ്സ് ഷഫിൾ ഉപയോഗിക്കാം.

സബ് ഫിഷർ_യേറ്റ്സ്_ഷഫിൾ {
എന്റെ $ ഡെക്ക് = ഷിഫ്റ്റ്; # $deck എന്നത് ഒരു അറേയുടെ ഒരു റഫറൻസാണ്
@$deck അല്ലാതെ മടങ്ങുക; # ശൂന്യമായിരിക്കരുത്!

എന്റെ $i = @$deck;
അതേസമയം (-$i) {
എന്റെ $j = int rand ($i+1);
@$ഡെക്ക്[$i,$j] = @$ഡെക്ക്[$j,$i];
}
}

# എന്റെ mpeg ശേഖരം ഷഫിൾ ചെയ്യുക
#
എന്റെ @mpeg = ;
fisher_yates_shuffle( \@mpeg ); സ്ഥലത്ത് @mpeg # ക്രമരഹിതമാക്കുക
പ്രിന്റ് @mpeg;

മേൽപ്പറഞ്ഞ നടപ്പിലാക്കൽ, അതിൽ നിന്ന് വ്യത്യസ്തമായി ഒരു അറേയെ മാറ്റുന്നു എന്നത് ശ്രദ്ധിക്കുക
"List::Util::shuffle()" അത് ഒരു ലിസ്റ്റ് എടുത്ത് ഒരു പുതിയ ഷഫിൾ ചെയ്ത ലിസ്റ്റ് നൽകുന്നു.

സ്‌പ്ലൈസ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന, ക്രമരഹിതമായി മറ്റൊന്ന് തിരഞ്ഞെടുക്കുന്ന അൽഗരിതങ്ങൾ ഷഫിൾ ചെയ്യുന്നത് നിങ്ങൾ കണ്ടിരിക്കാം
നിലവിലെ മൂലകത്തെ സ്വാപ്പ് ചെയ്യാനുള്ള ഘടകം

സ്രാൻഡ്;
@പുതിയ = ();
@ഓൾഡ് = 1 .. 10; # ഒരു ഡെമോ മാത്രം
സമയത്ത് (@പഴയത്) {
പുഷ്(@പുതിയ, സ്‌പ്ലൈസ്(@പഴയ, റാൻഡ് @പഴയ, 1));
}

ഇത് മോശമാണ്, കാരണം സ്പ്ലൈസ് ഇതിനകം തന്നെ O(N), നിങ്ങൾ ഇത് N തവണ ചെയ്യുന്നതിനാൽ, നിങ്ങൾ കണ്ടുപിടിച്ചതാണ്
ഒരു ക്വാഡ്രാറ്റിക് അൽഗോരിതം; അതായത് O(N**2). പേൾ അങ്ങനെയാണെങ്കിലും ഇത് സ്കെയിൽ ചെയ്യുന്നില്ല
നിങ്ങൾക്ക് വലിയ അറേകൾ ഉണ്ടാകുന്നതുവരെ നിങ്ങൾ ഇത് ശ്രദ്ധിക്കാനിടയില്ല എന്നത് കാര്യക്ഷമമാണ്.

എങ്ങനെ do I പ്രോസസ്സ് / പരിഷ്ക്കരിക്കുക ഓരോന്നും മൂലകം of an അറേ?
"for"/"foreach" ഉപയോഗിക്കുക:

(@ലൈനുകൾ) {
s/foo/bar/; # ആ വാക്ക് മാറ്റൂ
tr/XZ/ZX/; # ആ അക്ഷരങ്ങൾ സ്വാപ്പ് ചെയ്യുക
}

ഇതാ മറ്റൊന്ന്; നമുക്ക് ഗോളാകൃതിയിലുള്ള വോള്യങ്ങൾ കണക്കാക്കാം:

എന്റെ @വാള്യങ്ങൾ = @റേഡി;
വേണ്ടി (@volumes) { # @volumes ഭാഗങ്ങൾ മാറ്റി
$_ **= 3;
$_ *= (4/3) * 3.14159; # ഇത് സ്ഥിരമായി മടക്കിയിരിക്കും
}

ഒരു ലിസ്‌റ്റ് മറ്റൊന്നാക്കി മാറ്റാൻ നിർമ്മിച്ച "മാപ്പ്()" ഉപയോഗിച്ചും ഇത് ചെയ്യാം:

എന്റെ @വാള്യങ്ങൾ = മാപ്പ് {$_ ** 3 * (4/3) * 3.14159} @റേഡി;

ഹാഷിന്റെ മൂല്യങ്ങൾ പരിഷ്‌ക്കരിക്കുന്നതിന് നിങ്ങൾക്ക് ഇതേ കാര്യം ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം
"മൂല്യം" പ്രവർത്തനം. Perl 5.6 മുതൽ മൂല്യങ്ങൾ പകർത്തിയിട്ടില്ല, അതിനാൽ നിങ്ങൾ $ഓർബിറ്റ് പരിഷ്കരിക്കുകയാണെങ്കിൽ (ഇൻ
ഈ സാഹചര്യത്തിൽ), നിങ്ങൾ മൂല്യം പരിഷ്കരിക്കുന്നു.

എന്റെ $ഓർബിറ്റിനായി (മൂല്യങ്ങൾ %ഓർബിറ്റുകൾ ) {
($ ഓർബിറ്റ് **= 3) *= (4/3) * 3.14159;
}

perl 5.6 ന് മുമ്പ് "മൂല്യം" മൂല്യങ്ങളുടെ പകർപ്പുകൾ തിരികെ നൽകി, അതിനാൽ പലപ്പോഴും പഴയ perl കോഡ്
"values ​​%orbits" എന്നതിനുപകരം @orbits{keys %orbits} പോലുള്ള നിർമ്മാണങ്ങൾ അടങ്ങിയിരിക്കുന്നു
ഹാഷ് പരിഷ്കരിക്കണം.

എങ്ങനെ do I തെരഞ്ഞെടുക്കുക a ക്രമരഹിതം മൂലകം നിന്ന് an അറേ?
"rand()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക (perlfunc-ലെ "rand" കാണുക):

എന്റെ $ സൂചിക = rand @array;
എന്റെ $ഘടകം = $array[$index];

അല്ലെങ്കിൽ, ലളിതമായി:

എന്റെ $മൂലകം = $അറേ[റാൻഡ് @അറേ ];

എങ്ങനെ do I ക്രമപ്പെടുത്തുക N ഘടകങ്ങൾ of a പട്ടിക?
CPAN-ൽ ലിസ്റ്റ്::Permutor മൊഡ്യൂൾ ഉപയോഗിക്കുക. ലിസ്റ്റ് യഥാർത്ഥത്തിൽ ഒരു അറേ ആണെങ്കിൽ, ശ്രമിക്കുക
അൽഗോരിതം:: മൊഡ്യൂൾ പെർമ്യൂട്ടുചെയ്യുക (CPAN-ലും). ഇത് XS കോഡിൽ എഴുതിയിരിക്കുന്നു കൂടാതെ വളരെ കാര്യക്ഷമവുമാണ്:

അൽഗോരിതം ഉപയോഗിക്കുക:: പെർമ്യൂട്ടുചെയ്യുക;

my @array = 'a'..'d';
എന്റെ $p_iterator = അൽഗോരിതം::Permute->new ( \@array );

അതേസമയം (my @perm = $p_iterator->അടുത്തത്) {
"അടുത്ത ക്രമമാറ്റം: (@perm)\n";
}

ഇതിലും വേഗത്തിലുള്ള നിർവ്വഹണത്തിനായി, നിങ്ങൾക്ക് ഇവ ചെയ്യാനാകും:

അൽഗോരിതം ഉപയോഗിക്കുക:: പെർമ്യൂട്ടുചെയ്യുക;

my @array = 'a'..'d';

അൽഗോരിതം::പെർമ്യൂട്ട്::പെർമ്യൂട്ട് {
"അടുത്ത ക്രമമാറ്റം: (@array)\n";
} @അറേ;

ഓരോ വരിയിലും എല്ലാ പദങ്ങളുടെയും എല്ലാ ക്രമപ്പെടുത്തലുകളും സൃഷ്ടിക്കുന്ന ഒരു ചെറിയ പ്രോഗ്രാം ഇതാ
ഇൻപുട്ട്. "permute()" ഫംഗ്‌ഷനിൽ ഉൾക്കൊള്ളിച്ചിരിക്കുന്ന അൽഗോരിതം വോളിയം 4-ൽ (ഇപ്പോഴും
പ്രസിദ്ധീകരിക്കാത്തത്) Knuth ന്റെ ദി കല of കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗ് ഏത് ലിസ്റ്റിലും പ്രവർത്തിക്കും:

#!/usr/bin/perl -n
# ഫിഷർ-ക്രൗസ് പെർമ്യൂട്ടേഷൻ ജനറേറ്റർ ഓർഡർ ചെയ്തു

ഉപ ക്രമപ്പെടുത്തൽ (&@) {
എന്റെ $ കോഡ് = ഷിഫ്റ്റ്;
എന്റെ @idx = 0..$#_;
അതേസമയം ($code->(@_[@idx]) ) {
എന്റെ $p = $#idx;
--$p അതേസമയം $idx[$p-1] > $idx[$p];
എന്റെ $q = $p അല്ലെങ്കിൽ റിട്ടേൺ;
പുഷ് @idx, റിവേഴ്സ് സ്പ്ലൈസ് @idx, $p;
++$q അതേസമയം $idx[$p-1] > $idx[$q];
@idx[$p-1,$q]=@idx[$q,$p-1];
}
}

{print "@_\n"} വിഭജനം ക്രമപ്പെടുത്തുക;

അൽഗോരിതം::ലൂപ്സ് മൊഡ്യൂൾ "NextPermute", "NextPermuteNum" എന്നീ ഫംഗ്ഷനുകളും നൽകുന്നു
ഡ്യൂപ്ലിക്കേറ്റ് അടങ്ങിയിട്ടുണ്ടെങ്കിലും, ഒരു അറേയുടെ എല്ലാ അദ്വിതീയ പെർമ്യൂട്ടേഷനുകളും കാര്യക്ഷമമായി കണ്ടെത്തുന്നു
മൂല്യങ്ങൾ, അത് സ്ഥലത്തുതന്നെ പരിഷ്ക്കരിക്കുന്നു: അതിന്റെ ഘടകങ്ങൾ വിപരീത ക്രമത്തിലാണെങ്കിൽ, അറേ
തിരിച്ചും മറിച്ചും ക്രമപ്പെടുത്തിയും അത് തെറ്റായി തിരിച്ചുവരും; അല്ലെങ്കിൽ അടുത്ത ക്രമമാറ്റം
മടങ്ങി.

"NextPermute" സ്ട്രിംഗ് ഓർഡറും "NextPermuteNum" സംഖ്യാ ക്രമവും ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് എണ്ണാം
0..9 ന്റെ എല്ലാ ക്രമമാറ്റങ്ങളും ഇതുപോലെ:

അൽഗോരിതം ഉപയോഗിക്കുക::Loops qw(NextPermuteNum);

എന്റെ @ലിസ്റ്റ്= 0..9;
NextPermuteNum @list സമയത്ത് {print "@list\n"} ചെയ്യുക;

എങ്ങനെ do I അടുക്കുക an ശ്രേണി by (എന്തും)?
ഒരു താരതമ്യ പ്രവർത്തനം നൽകുക അടുക്കുക () (perlfunc-ൽ "ക്രമീകരിക്കുക" എന്നതിൽ വിവരിച്ചിരിക്കുന്നു):

@list = അടുക്കുക {$a <=> $b} @list;

"(1, 2, 10)" എന്നതിലേക്ക് അടുക്കുന്ന cmp, സ്ട്രിംഗ് താരതമ്യം ആണ് ഡിഫോൾട്ട് സോർട്ട് ഫംഗ്‌ഷൻ
"(1, 10, 2)". മുകളിൽ ഉപയോഗിച്ച "<=>", സംഖ്യാ താരതമ്യ ഓപ്പറേറ്ററാണ്.

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

എന്റെ @idx;
വേണ്ടി (@data) {
എന്റെ $ ഇനം;
($ഇനം) = /\d+\s*(\S+)/;
@idx, uc ($item) പുഷ് ചെയ്യുക;
}
my @sorted = @data[ അടുക്കുക {$idx[$a] cmp $idx[$b]} 0 .. $#idx ];

എന്ന് അറിയപ്പെടുന്ന ഒരു തന്ത്രം ഉപയോഗിച്ച് ഇത് ഇങ്ങനെയും എഴുതാം
ഷ്വാർട്സിയൻ പരിവർത്തനം:

എന്റെ @sorted = മാപ്പ് {$_->[0]}
അടുക്കുക { $a->[1] cmp $b->[1] }
മാപ്പ് { [ $_, uc( (/\d+\s*(\S+)/)[0]) ] } @data;

നിങ്ങൾക്ക് നിരവധി ഫീൽഡുകളിൽ അടുക്കണമെങ്കിൽ, ഇനിപ്പറയുന്ന മാതൃക ഉപയോഗപ്രദമാണ്.

എന്റെ @sorted = അടുക്കുക {
ഫീൽഡ്1($a) <=> ഫീൽഡ്1($b) ||
ഫീൽഡ്2($a) cmp ഫീൽഡ്2($b) ||
ഫീൽഡ്3($a) cmp ഫീൽഡ്3($b)
} @ഡാറ്റ;

മുകളിൽ നൽകിയിരിക്കുന്നത് പോലെ കീകളുടെ മുൻകൂർ കണക്കുകൂട്ടലുമായി ഇത് സൗകര്യപ്രദമായി സംയോജിപ്പിക്കാം.

കാണുക അടുക്കുക "നിങ്ങൾ എപ്പോഴെങ്കിലും അറിയാൻ ആഗ്രഹിച്ചതിലും കൂടുതൽ" എന്ന ശേഖരത്തിലെ ലേഖനം
<http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz> ഈ സമീപനത്തെക്കുറിച്ച് കൂടുതലറിയാൻ.

ഹാഷുകൾ അടുക്കുന്നതിനെക്കുറിച്ചുള്ള ചോദ്യം പിന്നീട് perlfaq4-ലും കാണുക.

എങ്ങനെ do I കൈകാര്യം ചെയ്യുക ശ്രേണികൾ of ബിറ്റുകൾ?
"പാക്ക്()", "അൺപാക്ക്()", അല്ലെങ്കിൽ "vec()" എന്നിവയും ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുക.

ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു അറേയിൽ വ്യക്തിഗത ബിറ്റുകൾ സംഭരിക്കേണ്ടതില്ല (അത് അർത്ഥമാക്കുന്നത്
നിങ്ങൾ ധാരാളം സ്ഥലം പാഴാക്കുന്നു). ബിറ്റുകളുടെ ഒരു നിരയെ ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, "vec()" to ഉപയോഗിക്കുക
ശരിയായ ബിറ്റുകൾ സജ്ജമാക്കുക. $ints[N] സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ മാത്രം ഇത് $vec-നെ ബിറ്റ് N ആയി സജ്ജീകരിക്കുന്നു:

എന്റെ @ints = (...); ബിറ്റുകളുടെ # നിര, ഉദാ ( 1, 0, 0, 1, 1, 0 ... )
എന്റെ $vec = '';
foreach( 0 .. $#ints ) {
vec($vec,$_,1) = 1 എങ്കിൽ $ints[$_];
}

$vec എന്ന സ്ട്രിംഗ് അതിന് ആവശ്യമുള്ളത്ര ബിറ്റുകൾ മാത്രമേ എടുക്കൂ. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് 16 ഉണ്ടെങ്കിൽ
@ints, $vec എന്നതിലെ എൻട്രികൾ സംഭരിക്കാൻ രണ്ട് ബൈറ്റുകൾ മാത്രമേ ആവശ്യമുള്ളൂ (സ്കെയിലർ കണക്കാക്കുന്നില്ല
വേരിയബിൾ ഓവർഹെഡ്).

$vec-ൽ ഒരു വെക്റ്റർ നൽകിയാൽ, ആ ബിറ്റുകൾ നിങ്ങളുടെ @ints അറേയിലേക്ക് എങ്ങനെ ലഭിക്കുമെന്നത് ഇതാ:

ഉപ bitvec_to_list {
എന്റെ $vec = shift;
എന്റെ @ints;
# നൾ-ബൈറ്റ് സാന്ദ്രത കണ്ടെത്തി മികച്ച അൽഗോരിതം തിരഞ്ഞെടുക്കുക
എങ്കിൽ ($vec =~ tr/\0// / നീളം $vec > 0.95) {
പൂർണ്ണസംഖ്യ ഉപയോഗിക്കുക;
എന്റെ $i;

# ഈ രീതി കൂടുതലും നൾ-ബൈറ്റുകൾ ഉപയോഗിച്ച് വേഗതയുള്ളതാണ്
അതേസമയം($vec =~ /[^\0]/g ) {
$i = -9 + 8 * pos $vec;
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
പുഷ് @ints, $i എങ്കിൽ vec($vec, ++$i, 1);
}
}
else {
# ഈ രീതി ഒരു ഫാസ്റ്റ് ജനറൽ അൽഗോരിതം ആണ്
പൂർണ്ണസംഖ്യ ഉപയോഗിക്കുക;
എന്റെ $ബിറ്റുകൾ = "b*", $vec അൺപാക്ക് ചെയ്യുക;
പുഷ് @ints, 0 എങ്കിൽ $bits =~ s/^(\d)// && $1;
പുഷ് @ints, pos $bits അതേസമയം($bits =~ /1/g);
}

റിട്ടേൺ \@ints;
}

ബിറ്റ് വെക്റ്റർ കൂടുതൽ വിരളമാകുമ്പോൾ ഈ രീതി വേഗത്തിലാകുന്നു. (ടിം ബൻസ് കടപ്പാട് ഒപ്പം
വിൻഫ്രൈഡ് കൊയിനിഗ്.)

ബെഞ്ചമിൻ ഗോൾഡ്ബെർഗിൽ നിന്നുള്ള ഈ നിർദ്ദേശം ഉപയോഗിച്ച് നിങ്ങൾക്ക് വേൾ ലൂപ്പ് വളരെ ചെറുതാക്കാം:

അതേസമയം($vec =~ /[^\0]+/g ) {
പുഷ് @ints, grep vec($vec, $_, 1), $-[0] * 8 .. $+[0] * 8;
}

അല്ലെങ്കിൽ CPAN മൊഡ്യൂൾ Bit::Vector: ഉപയോഗിക്കുക

എന്റെ $ വെക്റ്റർ = ബിറ്റ്:: വെക്റ്റർ->പുതിയ($num_of_bits);
$vector->Index_List_Store(@ints);
my @ints = $vector->Index_List_Read();

ബിറ്റ്:: വെക്റ്റർ ബിറ്റ് വെക്റ്റർ, ചെറിയ പൂർണ്ണസംഖ്യകളുടെ സെറ്റുകൾ, "ബിഗ്" എന്നിവയ്‌ക്ക് കാര്യക്ഷമമായ രീതികൾ നൽകുന്നു
int" ഗണിതം.

ഉപയോഗിച്ചുള്ള കൂടുതൽ വിപുലമായ ഒരു ചിത്രീകരണം ഇതാ vec():

# vec ഡെമോ
എന്റെ $വെക്റ്റർ = "\xff\x0f\xef\xfe";
പ്രിന്റ് "ഇല്യയുടെ സ്ട്രിംഗ് \\xff\\x0f\\xef\\xfe എന്ന സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു",
അൺപാക്ക്("N", $vector), "\n";
എന്റെ $is_set = vec($ വെക്റ്റർ, 23, 1);
"അതിന്റെ 23-ാമത്തെ ബിറ്റ് ", $is_set ? "set" : "clear", ".\n";
pvec ($ വെക്റ്റർ);

set_vec(1,1,1);
set_vec(3,1,1);
set_vec(23,1,1);

set_vec(3,1,3);
set_vec(3,2,3);
set_vec(3,4,3);
set_vec(3,4,7);
set_vec(3,8,3);
set_vec(3,8,7);

set_vec(0,32,17);
set_vec(1,32,17);

ഉപ set_vec {
എന്റെ ($ ഓഫ്സെറ്റ്, $ വീതി, $ മൂല്യം) = @_;
എന്റെ $വെക്റ്റർ = '';
vec($വെക്റ്റർ, $ഓഫ്സെറ്റ്, $വിഡ്ത്ത്) = $മൂല്യം;
പ്രിന്റ് "ഓഫ്സെറ്റ് = $ ഓഫ്സെറ്റ് വീതി = $ വീതി മൂല്യം = $ മൂല്യം\n";
pvec ($ വെക്റ്റർ);
}

sub pvec {
എന്റെ $ വെക്റ്റർ = ഷിഫ്റ്റ്;
എന്റെ $ബിറ്റുകൾ = അൺപാക്ക് ("ബി*", $വെക്റ്റർ);
എന്റെ $i = 0;
എന്റെ $ബേസ് = 8;

"വെക്റ്റർ നീളം ബൈറ്റുകളിൽ അച്ചടിക്കുക: ", ദൈർഘ്യം($ വെക്റ്റർ), "\n";
@ബൈറ്റുകൾ = അൺപാക്ക് ("A8" x നീളം($വെക്റ്റർ), $ബിറ്റുകൾ);
പ്രിന്റ് "ബിറ്റുകൾ ഇവയാണ്: @bytes\n\n";
}

എന്തുകൊണ്ട് ചെയ്യുന്നവൻ നിർവചിച്ച () മടക്കം യഥാർഥ on ശൂന്യമാണ് ശ്രേണികൾ ഒപ്പം ഹാഷുകൾ?
നിങ്ങൾ ഒരുപക്ഷേ സ്കെയിലറുകളിലോ ഫംഗ്ഷനുകളിലോ നിർവചിച്ചിരിക്കുന്നത് മാത്രമേ ഉപയോഗിക്കാവൂ എന്നതാണ് ചെറുകഥ
അഗ്രഗേറ്റുകളിൽ (അറേകളും ഹാഷുകളും). 5.004 പതിപ്പിലോ അതിനുശേഷമോ ഉള്ള perlfunc-ൽ "defined" കാണുക
കൂടുതൽ വിശദാംശങ്ങൾക്ക് പേൾ.

ഡാറ്റ: ഹാഷുകൾ (അസോസിയേറ്റീവ് അണികൾ)

എങ്ങനെ do I പ്രക്രിയ an മുഴുവൻ ഹാഷ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് മുഴുവൻ ഹാഷും പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന രണ്ട് വഴികളുണ്ട്. നിങ്ങൾക്ക് ഒരു ലിസ്റ്റ് ലഭിക്കും
കീകൾ, തുടർന്ന് ഓരോ കീയിലൂടെയും പോകുക, അല്ലെങ്കിൽ ഒരു സമയം ഒരു കീ-മൂല്യം ജോടി പിടിക്കുക.

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

എന്റെ $കീ (കീകൾ %hash) {
എന്റെ $മൂല്യം = $hash{$key}
...
}

നിങ്ങൾക്ക് കീകളുടെ ലിസ്റ്റ് ലഭിച്ചുകഴിഞ്ഞാൽ, ഹാഷ് പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് നിങ്ങൾക്ക് ആ ലിസ്റ്റ് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും
ഘടകങ്ങൾ. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് കീകൾ അടുക്കാൻ കഴിയും, അതിനാൽ നിങ്ങൾക്ക് അവയെ ലെക്സിക്കൽ ക്രമത്തിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും:

എന്റെ $കീ (%hash കീകൾ അടുക്കുക) {
എന്റെ $മൂല്യം = $hash{$key}
...
}

അല്ലെങ്കിൽ, ചില ഇനങ്ങൾ മാത്രം പ്രോസസ്സ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. നിങ്ങൾ കൈകാര്യം ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ മാത്രം
"text:" എന്ന് തുടങ്ങുന്ന കീകൾ, "grep" ഉപയോഗിക്കുന്നവ മാത്രം നിങ്ങൾക്ക് തിരഞ്ഞെടുക്കാം:

എന്റെ $കീ ( grep /^text:/, കീകൾ %hash ) ഫോറെച്ച് ചെയ്യുക {
എന്റെ $മൂല്യം = $hash{$key}
...
}

ഹാഷ് വളരെ വലുതാണെങ്കിൽ, കീകളുടെ ഒരു നീണ്ട ലിസ്റ്റ് സൃഷ്ടിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കില്ല. കുറച്ച് സംരക്ഷിക്കാൻ
മെമ്മറി, "ഓരോ ()" ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സമയം ഒരു കീ-മൂല്യം ജോടി പിടിക്കാം, അത് നിങ്ങൾക്ക് ഒരു ജോഡി നൽകുന്നു
ഇതുവരെ കണ്ടിട്ടില്ല:

അതേസമയം(എന്റെ($കീ, $മൂല്യം) = ഓരോന്നും(%hash) ) {
...
}

"ഓരോ" ഓപ്പറേറ്ററും ജോഡികളെ പ്രത്യക്ഷത്തിൽ ക്രമരഹിതമായ ക്രമത്തിൽ തിരികെ നൽകുന്നു, അതിനാൽ ഓർഡർ ചെയ്യുന്നതാണ് പ്രധാനമെങ്കിൽ
നിങ്ങളോട്, നിങ്ങൾ "കീ" രീതിയുമായി ചേർന്ന് നിൽക്കണം.

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

എങ്ങനെ do I ലയിപ്പിക്കുക രണ്ട് ഹാഷുകൾ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

രണ്ട് ഹാഷുകളും ലയിപ്പിക്കാൻ തീരുമാനിക്കുന്നതിന് മുമ്പ്, രണ്ട് ഹാഷുകളും ഉണ്ടെങ്കിൽ എന്തുചെയ്യണമെന്ന് നിങ്ങൾ തീരുമാനിക്കേണ്ടതുണ്ട്
ഒരേ പോലെയുള്ള കീകൾ അടങ്ങിയിരിക്കുന്നു, നിങ്ങൾക്ക് യഥാർത്ഥ ഹാഷുകൾ അതേപടി ഉപേക്ഷിക്കണമെങ്കിൽ.

നിങ്ങൾക്ക് യഥാർത്ഥ ഹാഷുകൾ സംരക്ഷിക്കണമെങ്കിൽ, ഒരു ഹാഷ് (%hash1) ഒരു പുതിയ ഹാഷിലേക്ക് പകർത്തുക
(%new_hash), തുടർന്ന് മറ്റൊരു ഹാഷിൽ നിന്ന് കീകൾ ചേർക്കുക (%hash2 പുതിയ ഹാഷിലേക്ക്. അത് പരിശോധിക്കുന്നു
%new_hash-ൽ ഇതിനകം നിലവിലിരിക്കുന്ന കീ നിങ്ങൾക്ക് എന്ത് ചെയ്യണമെന്ന് തീരുമാനിക്കാനുള്ള അവസരം നൽകുന്നു
തനിപ്പകർപ്പുകൾ:

എന്റെ %new_hash = %hash1; # ഒരു കോപ്പി ഉണ്ടാക്കുക; %hash1 മാത്രം വിടുക

എന്റെ $key2 (കീകൾ %hash2) {
($new_hash{$key2} നിലവിലുണ്ടെങ്കിൽ) {
മുന്നറിയിപ്പ് "കീ [$കീ2] രണ്ട് ഹാഷുകളിലും ഉണ്ട്!";
# തനിപ്പകർപ്പ് കൈകാര്യം ചെയ്യുക (ഒരുപക്ഷേ മുന്നറിയിപ്പ് മാത്രം)
...
അടുത്തത്;
}
else {
$new_hash{$key2} = $hash2{$key2};
}
}

നിങ്ങൾക്ക് ഒരു പുതിയ ഹാഷ് സൃഷ്ടിക്കാൻ താൽപ്പര്യമില്ലെങ്കിൽ, നിങ്ങൾക്ക് തുടർന്നും ഈ ലൂപ്പിംഗ് ടെക്നിക് ഉപയോഗിക്കാം; വെറും
% new_hash %hash1 ആയി മാറ്റുക.

എന്റെ $key2 (കീകൾ %hash2) {
എങ്കിൽ ($hash1{$key2} നിലവിലുണ്ട്) {
മുന്നറിയിപ്പ് "കീ [$കീ2] രണ്ട് ഹാഷുകളിലും ഉണ്ട്!";
# തനിപ്പകർപ്പ് കൈകാര്യം ചെയ്യുക (ഒരുപക്ഷേ മുന്നറിയിപ്പ് മാത്രം)
...
അടുത്തത്;
}
else {
$hash1{$key2} = $hash2{$key2};
}
}

ഒരു ഹാഷ് മറ്റൊന്നിൽ നിന്ന് കീകളും മൂല്യങ്ങളും തിരുത്തിയെഴുതുന്നത് നിങ്ങൾ കാര്യമാക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് ഇത് ചെയ്യാം
ഒരു ഹാഷ് മറ്റൊന്നിലേക്ക് ചേർക്കാൻ ഒരു ഹാഷ് സ്ലൈസ് ഉപയോഗിക്കുക. ഈ സാഹചര്യത്തിൽ, %hash2-ൽ നിന്നുള്ള മൂല്യങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നു
പൊതുവായ കീകൾ ഉള്ളപ്പോൾ %hash1-ൽ നിന്നുള്ള മൂല്യങ്ങൾ:

@hash1{കീകൾ %hash2 } = മൂല്യങ്ങൾ %hash2;

എന്ത് സംഭവിക്കുന്നു if I ചേർക്കുക or നീക്കം കീകൾ നിന്ന് a ഹാഷ് സമയത്ത് ആവർത്തിക്കുന്നു മേൽ ഇത്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

എളുപ്പമുള്ള ഉത്തരം "അങ്ങനെ ചെയ്യരുത്!"

നിങ്ങൾ ഹാഷിലൂടെ ആവർത്തിക്കുകയാണെങ്കിൽ ഓരോ (), നിങ്ങൾക്ക് ഏറ്റവും അടുത്തിടെ നൽകിയ കീ ഇല്ലാതാക്കാം
അതിനെക്കുറിച്ച് വിഷമിക്കാതെ. നിങ്ങൾ ഇല്ലാതാക്കുകയോ മറ്റ് കീകൾ ചേർക്കുകയോ ചെയ്താൽ, ഇറ്ററേറ്റർ ഒഴിവാക്കാം അല്ലെങ്കിൽ
perl ഹാഷ് ടേബിൾ പുനഃക്രമീകരിച്ചേക്കാമെന്നതിനാൽ അവയിൽ ഇരട്ടിയാക്കുക. "ഓരോ()" എന്നതിനായുള്ള എൻട്രി കാണുക
പെർഫങ്ക്.

എങ്ങനെ do I നോക്കൂ up a ഹാഷ് മൂലകം by മൂല്യം?
ഒരു റിവേഴ്സ് ഹാഷ് സൃഷ്ടിക്കുക:

എന്റെ %by_value = വിപരീത %by_key;
എന്റെ $കീ = $by_value{$value};

അത് പ്രത്യേകിച്ച് കാര്യക്ഷമമല്ല. ഇത് ഉപയോഗിക്കുന്നത് കൂടുതൽ സ്ഥല-കാര്യക്ഷമമായിരിക്കും:

അതേസമയം (എന്റെ ($കീ, $മൂല്യം) = ഓരോ %by_key) {
$by_value{$value} = $കീ;
}

നിങ്ങളുടെ ഹാഷിന് ആവർത്തിച്ചുള്ള മൂല്യങ്ങൾ ഉണ്ടെങ്കിൽ, മുകളിലുള്ള രീതികളിൽ ഒന്ന് മാത്രമേ കണ്ടെത്തൂ
ബന്ധപ്പെട്ട കീകൾ. ഇത് നിങ്ങളെ വിഷമിപ്പിച്ചേക്കാം അല്ലെങ്കിൽ വിഷമിപ്പിക്കില്ല. ഇത് നിങ്ങളെ വിഷമിപ്പിക്കുന്നുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും കഴിയും
പകരം ഹാഷിനെ അറേകളുടെ ഹാഷിലേക്ക് മാറ്റുക:

അതേസമയം (എന്റെ ($കീ, $മൂല്യം) = ഓരോ %by_key) {
@{$key_list_by_value{$value}}, $കീ അമർത്തുക;
}

എങ്ങനെ കഴിയും I അറിയുക എങ്ങനെ വളരെ എൻട്രികൾ ആകുന്നു in a ഹാഷ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഇത് perlfaq4-ലും "എങ്ങനെ ഒരു മുഴുവൻ ഹാഷും പ്രോസസ്സ് ചെയ്യാം?" എന്നതുമായി വളരെ സാമ്യമുള്ളതാണ്, പക്ഷേ അൽപ്പം
സാധാരണ കേസുകളിൽ ലളിതമാണ്.

നിരവധി എൻട്രികൾ ഉണ്ടെന്ന് കണ്ടെത്താൻ നിങ്ങൾക്ക് സ്കെയിലർ സന്ദർഭത്തിൽ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ "കീ()" ഉപയോഗിക്കാം
നിങ്ങൾക്ക് ഒരു ഹാഷിൽ ഉണ്ട്:

എന്റെ $key_count = കീകൾ %hash; # സ്കെയിലർ സന്ദർഭം ആയിരിക്കണം!

എത്ര എൻട്രികൾക്ക് നിർവചിക്കപ്പെട്ട മൂല്യമുണ്ടെന്ന് കണ്ടെത്തണമെങ്കിൽ, അത് അൽപ്പം വ്യത്യസ്തമാണ്. നിങ്ങൾ
ഓരോ മൂല്യവും പരിശോധിക്കേണ്ടതുണ്ട്. ഒരു "ഗ്രെപ്പ്" സുലഭമാണ്:

എന്റെ $defined_value_count = grep {defined} മൂല്യങ്ങൾ %hash;

നിങ്ങൾക്ക് ഇഷ്ടമുള്ള രീതിയിൽ എൻട്രികൾ എണ്ണാൻ അതേ ഘടന ഉപയോഗിക്കാം. നിങ്ങൾക്ക് വേണമെങ്കിൽ
സ്വരാക്ഷരങ്ങളുള്ള കീകളുടെ എണ്ണം, പകരം നിങ്ങൾ അത് പരീക്ഷിക്കുക:

എന്റെ $vowel_count = grep { /[aeiou]/} കീകൾ %hash;

സ്കെയിലർ സന്ദർഭത്തിലെ "grep" എണ്ണം നൽകുന്നു. നിങ്ങൾക്ക് പൊരുത്തപ്പെടുന്ന ഇനങ്ങളുടെ ലിസ്റ്റ് വേണമെങ്കിൽ,
പകരം ലിസ്റ്റ് സന്ദർഭത്തിൽ ഉപയോഗിക്കുക:

my @defined_values ​​= grep {defined} മൂല്യങ്ങൾ %hash;

"കീകൾ()" ഫംഗ്‌ഷൻ ഇറ്ററേറ്ററിനെ പുനഃസജ്ജമാക്കുകയും ചെയ്യുന്നു, അതിനർത്ഥം നിങ്ങൾ വിചിത്രമായി കണ്ടേക്കാം എന്നാണ്
"each()" പോലുള്ള മറ്റ് ഹാഷ് ഓപ്പറേറ്റർമാരുടെ ഉപയോഗങ്ങൾക്കിടയിൽ നിങ്ങൾ ഇത് ഉപയോഗിക്കുകയാണെങ്കിൽ ഫലം ലഭിക്കും.

എങ്ങനെ do I അടുക്കുക a ഹാഷ് (ഓപ്ഷണലായി by മൂല്യം പകരം of കീ)?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ഒരു ഹാഷ് അടുക്കാൻ, കീകൾ ഉപയോഗിച്ച് ആരംഭിക്കുക. ഈ ഉദാഹരണത്തിൽ, സോർട്ടിനുള്ള കീകളുടെ ലിസ്റ്റ് ഞങ്ങൾ നൽകുന്നു
പിന്നീട് അവയെ ആസ്കിബെറ്റിക്കലായി താരതമ്യം ചെയ്യുന്ന പ്രവർത്തനം (ഇത് നിങ്ങളുടെ ഭാഷയെ ബാധിച്ചേക്കാം
ക്രമീകരണങ്ങൾ). ഔട്ട്പുട്ട് ലിസ്റ്റിൽ ASCIIBetical ക്രമത്തിൽ കീകൾ ഉണ്ട്. താക്കോൽ ലഭിച്ചുകഴിഞ്ഞാൽ, ഞങ്ങൾ
ASCIIbetical ക്രമത്തിൽ കീകൾ ലിസ്റ്റുചെയ്യുന്ന ഒരു റിപ്പോർട്ട് സൃഷ്ടിക്കാൻ അവയിലൂടെ പോകാം.

എന്റെ @കീകൾ = അടുക്കുക {$a cmp $b} കീകൾ %hash;

എന്റെ $കീ (@കീകൾ) {
printf "%-20s %6d\n", $key, $hash{$key};
}

എന്നിരുന്നാലും "സോർട്ട്()" ബ്ലോക്കിൽ നമുക്ക് കൂടുതൽ ഫാൻസി ലഭിക്കും. കീകൾ താരതമ്യം ചെയ്യുന്നതിനുപകരം, ഞങ്ങൾ
അവയുമായി ഒരു മൂല്യം കണക്കാക്കാനും ആ മൂല്യം താരതമ്യമായി ഉപയോഗിക്കാനും കഴിയും.

ഉദാഹരണത്തിന്, ഞങ്ങളുടെ റിപ്പോർട്ട് ഓർഡർ കേസ്-ഇൻസെൻസിറ്റീവ് ആക്കുന്നതിന്, കീകൾ ചെറിയക്ഷരമാക്കാൻ ഞങ്ങൾ "lc" ഉപയോഗിക്കുന്നു
അവയെ താരതമ്യം ചെയ്യുന്നതിനുമുമ്പ്:

എന്റെ @കീകൾ = അടുക്കുക {lc $a cmp lc $b } കീകൾ %hash;

ശ്രദ്ധിക്കുക: കണക്കുകൂട്ടൽ ചെലവേറിയതാണെങ്കിൽ അല്ലെങ്കിൽ ഹാഷിന് നിരവധി ഘടകങ്ങൾ ഉണ്ടെങ്കിൽ, നിങ്ങൾ നോക്കാൻ ആഗ്രഹിച്ചേക്കാം
കമ്പ്യൂട്ടേഷൻ ഫലങ്ങൾ കാഷെ ചെയ്യാൻ ഷ്വാർട്സിയൻ ട്രാൻസ്ഫോമിൽ.

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

my @keys = അടുക്കുക {$hash{$a} <=> $hash{$b}} കീകൾ %hash;

അവിടെ നിന്ന് നമുക്ക് കൂടുതൽ സങ്കീർണ്ണമാകാം. ഹാഷ് മൂല്യങ്ങൾ ഒന്നുതന്നെയാണെങ്കിൽ, നമുക്ക് a നൽകാം
ഹാഷ് കീയിൽ ദ്വിതീയ തരം.

എന്റെ @കീകൾ = അടുക്കുക {
$hash{$a} <=> $hash{$b}
or
"\L$a" cmp "\L$b"
} കീകൾ %hash;

എങ്ങനെ കഴിയും I എല്ലായിപ്പോഴും സൂക്ഷിക്കുക my ഹാഷ് അടുക്കിയോ?
$DB_BTREE ഹാഷ് ബൈൻഡിംഗുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് "DB_File" മൊഡ്യൂളും "ടൈ()" ഉം ഉപയോഗിക്കുന്നത് പരിശോധിക്കാം
DB_File ലെ "ഇൻ മെമ്മറി ഡാറ്റാബേസുകളിൽ" രേഖപ്പെടുത്തിയിരിക്കുന്നത് പോലെ. CPAN-ൽ നിന്നുള്ള ടൈ:: IxHash ഘടകം
പ്രബോധനപരവും ആയിരിക്കുക. ഇത് നിങ്ങളുടെ ഹാഷിനെ ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിലും, നിങ്ങൾക്ക് ഇത് ഇഷ്ടപ്പെട്ടേക്കില്ല
ടൈ ഇന്റർഫേസിൽ നിന്നുള്ള വേഗത കുറയുന്നു. നിങ്ങൾ ഇത് ചെയ്യണമെന്ന് ഉറപ്പാണോ? :)

എന്താണ് The വ്യത്യാസം തമ്മിലുള്ള "ഇല്ലാതാക്കുക" ഒപ്പം "undef" കൂടെ ഹാഷുകൾ?
ഹാഷുകളിൽ ജോഡി സ്കെയിലറുകൾ അടങ്ങിയിരിക്കുന്നു: ആദ്യത്തേത് കീയാണ്, രണ്ടാമത്തേത് മൂല്യമാണ്. താക്കോല്
മൂല്യം ഏതെങ്കിലും തരത്തിലുള്ള സ്കെയിലർ ആയിരിക്കാമെങ്കിലും, ഒരു സ്ട്രിംഗിലേക്ക് നിർബന്ധിതമാക്കപ്പെടും: സ്ട്രിംഗ്, നമ്പർ,
അല്ലെങ്കിൽ റഫറൻസ്. %hash-ൽ ഒരു കീ $കീ ഉണ്ടെങ്കിൽ, "നിലവിലുണ്ട്($hash{$key})" ശരിയാണെന്ന് തിരികെ നൽകും.
തന്നിരിക്കുന്ന കീയുടെ മൂല്യം "undef" ആയിരിക്കാം, ഈ സാഹചര്യത്തിൽ $hash{$key} "undef" ആയിരിക്കും.
"നിലവിലുണ്ട് $hash{$key}" സത്യമായി നൽകും. ഇത് ($key, "undef") എന്നതിനോട് യോജിക്കുന്നു
ഹാഷ്.

ചിത്രങ്ങൾ സഹായിക്കുന്നു... %ഹാഷ് പട്ടിക ഇതാ:

കീ മൂല്യങ്ങൾ
+------+------+
| ഒരു | 3 |
| x | 7 |
| d | 0 |
| ഇ | 2 |
+------+------+

ഈ വ്യവസ്ഥകളും നിലനിൽക്കുന്നു

$hash{'a'} ശരിയാണ്
$hash{'d'} എന്നത് തെറ്റാണ്
നിർവചിച്ച $hash{'d'} ശരിയാണ്
നിർവചിച്ച $hash{'a'} ശരിയാണ്
നിലവിലുണ്ട് $hash{'a'} ശരിയാണ് (Perl 5 മാത്രം)
grep ($_ eq 'a', കീകൾ %hash) ശരിയാണ്

ഇപ്പോൾ പറഞ്ഞാൽ

undef $hash{'a'}

നിങ്ങളുടെ പട്ടിക ഇപ്പോൾ വായിക്കുന്നു:

കീ മൂല്യങ്ങൾ
+------+------+
| ഒരു | undef|
| x | 7 |
| d | 0 |
| ഇ | 2 |
+------+------+

ഈ വ്യവസ്ഥകൾ ഇപ്പോൾ നിലനിൽക്കുന്നു; തൊപ്പിയിലെ മാറ്റങ്ങൾ:

$hash{'a'} തെറ്റാണ്
$hash{'d'} എന്നത് തെറ്റാണ്
നിർവചിച്ച $hash{'d'} ശരിയാണ്
നിർവ്വചിച്ച $hash{'a'} തെറ്റാണ്
നിലവിലുണ്ട് $hash{'a'} ശരിയാണ് (Perl 5 മാത്രം)
grep ($_ eq 'a', കീകൾ %hash) ശരിയാണ്

അവസാനത്തെ രണ്ട് ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ഒരു undef മൂല്യമുണ്ട്, എന്നാൽ ഒരു നിർവചിക്കപ്പെട്ട കീ!

ഇപ്പോൾ, ഇത് പരിഗണിക്കുക:

$hash{'a'} ഇല്ലാതാക്കുക

നിങ്ങളുടെ പട്ടിക ഇപ്പോൾ വായിക്കുന്നു:

കീ മൂല്യങ്ങൾ
+------+------+
| x | 7 |
| d | 0 |
| ഇ | 2 |
+------+------+

ഈ വ്യവസ്ഥകൾ ഇപ്പോൾ നിലനിൽക്കുന്നു; തൊപ്പിയിലെ മാറ്റങ്ങൾ:

$hash{'a'} എന്നത് തെറ്റാണ്
$hash{'d'} എന്നത് തെറ്റാണ്
നിർവചിച്ച $hash{'d'} ശരിയാണ്
$hash{'a'} എന്നത് തെറ്റാണ്
നിലവിലുണ്ട് $hash{'a'} തെറ്റാണ് (Perl 5 മാത്രം)
grep ($_ eq 'a', കീകൾ %hash) തെറ്റാണ്

നോക്കൂ, മുഴുവൻ പ്രവേശനവും പോയി!

എന്തുകൊണ്ട് ചെയ്യരുത് my കെട്ടിയിട്ടു ഹാഷുകൾ ഉണ്ടാക്കുക The നിർവചിച്ചിരിക്കുന്നു/നിലവിലുണ്ട് വ്യത്യാസം?
ഇത് ടൈഡ് ഹാഷ് നടപ്പിലാക്കുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു നിലവിലുണ്ട്(). ഉദാഹരണത്തിന്, ഇല്ല
ഡിബിഎം* ഫയലുകളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഹാഷുകളുള്ള undef എന്ന ആശയം. എന്നും അർത്ഥമുണ്ട് നിലവിലുണ്ട് () ഒപ്പം
നിർവചിച്ച () ഒരു DBM* ഫയലിലും ഇതുതന്നെ ചെയ്യുക, അവസാനം അവർ ചെയ്യുന്നത് അവർ ചെയ്യുന്നതല്ല
സാധാരണ ഹാഷുകൾ ഉപയോഗിച്ച് ചെയ്യുക.

എങ്ങനെ do I പുനഃസജ്ജമാക്കുക an ഓരോ () ഓപ്പറേഷൻ ഭാഗികമായി വഴി?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

"ഓരോന്നും" പുനഃസജ്ജമാക്കാൻ നിങ്ങൾക്ക് "കീകൾ" അല്ലെങ്കിൽ "മൂല്യങ്ങൾ" ഫംഗ്ഷനുകൾ ഉപയോഗിക്കാം. ഇറ്ററേറ്റർ പുനഃസജ്ജമാക്കാൻ
മറ്റൊന്നും ചെയ്യാതെ "ഓരോരുത്തരും" ഉപയോഗിക്കുന്നു, അവയിലൊന്ന് അസാധുവായ സന്ദർഭത്തിൽ ഉപയോഗിക്കുക:

കീകൾ % ഹാഷ്; # റീസെറ്റ് ഇറ്ററേറ്റർ, മറ്റൊന്നുമല്ല.
മൂല്യങ്ങൾ % ഹാഷ്; # റീസെറ്റ് ഇറ്ററേറ്റർ, മറ്റൊന്നുമല്ല.

perlfunc-ൽ "ഓരോന്നിനും" ഡോക്യുമെന്റേഷൻ കാണുക.

എങ്ങനെ കഴിയും I നേടുക The അതുല്യമായ കീകൾ നിന്ന് രണ്ട് ഹാഷുകൾ?
ആദ്യം നിങ്ങൾ ഹാഷുകളിൽ നിന്ന് ലിസ്റ്റുകളിലേക്ക് കീകൾ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുക, തുടർന്ന് "നീക്കംചെയ്യൽ" പരിഹരിക്കുക
മുകളിൽ വിവരിച്ച ഡ്യൂപ്ലിക്കേറ്റ്" പ്രശ്നം. ഉദാഹരണത്തിന്:

എന്റെ %സീൻ = ();
എന്റെ $ഘടകത്തിന് (കീകൾ(%foo), കീകൾ(%bar)) {
$seen{$element}++;
}
എന്റെ @uniq = കീകൾ %കണ്ടു;

അല്ലെങ്കിൽ കൂടുതൽ സംക്ഷിപ്തമായി:

എന്റെ @uniq = കീകൾ %{{%foo,%bar}};

അല്ലെങ്കിൽ നിങ്ങൾക്ക് ശരിക്കും സ്ഥലം ലാഭിക്കണമെങ്കിൽ:

എന്റെ %സീൻ = ();
അതേസമയം (നിർവചിച്ചിരിക്കുന്നത് ($കീ = ഓരോ %foo)) {
$seen{$key}++;
}
അതേസമയം (നിർവചിച്ചിരിക്കുന്നത് ($കീ = ഓരോ %ബാറും)) {
$seen{$key}++;
}
എന്റെ @uniq = കീകൾ %കണ്ടു;

എങ്ങനെ കഴിയും I സ്റ്റോർ a മൾട്ടി-ഡൈമെൻഷണൽ ശ്രേണി in a ഡി.ബി.എം. ഫയൽ?
ഒന്നുകിൽ ഘടന സ്വയം കർശനമാക്കുക (രസകരമല്ല), അല്ലെങ്കിൽ MLDBM നേടുക (അത് ഉപയോഗിക്കുന്നു
ഡാറ്റ::ഡമ്പർ) CPAN-ൽ നിന്നുള്ള മൊഡ്യൂൾ, അത് DB_File അല്ലെങ്കിൽ GDBM_File-ന് മുകളിൽ ലെയർ ചെയ്യുക. നിങ്ങൾ
DBM::Deep എന്നിവയും ശ്രമിക്കാം, പക്ഷേ ഇത് അൽപ്പം മന്ദഗതിയിലാകും.

എങ്ങനെ കഴിയും I ഉണ്ടാക്കുക my ഹാഷ് ഓർമ്മിക്കുക The ഓർഡർ I ഇടുക ഘടകങ്ങൾ കടന്നു ഇത്?
CPAN-ൽ നിന്നുള്ള ടൈ::IxHash ഉപയോഗിക്കുക.

ടൈ :: IxHash ഉപയോഗിക്കുക;

ടൈ എന്റെ %myhash, 'Tie::IxHash';

ഇതിനായി (എന്റെ $i=0; $i<20; $i++) {
$myhash{$i} = 2*$i;
}

എന്റെ @കീകൾ = കീകൾ %myhash;
# @കീകൾ = (0,1,2,3,...)

എന്തുകൊണ്ട് ചെയ്യുന്നവൻ പാസിംഗ് a സബ്റൂട്ടീൻ an വ്യക്തമല്ല മൂലകം in a ഹാഷ് സൃഷ്ടിക്കാൻ ഇത്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

നിങ്ങൾ Perl-ന്റെ ശരിക്കും പഴയ പതിപ്പാണോ ഉപയോഗിക്കുന്നത്?

സാധാരണയായി, നിലവിലില്ലാത്ത ഒരു കീയ്‌ക്കായി ഒരു ഹാഷ് കീയുടെ മൂല്യം ആക്‌സസ് ചെയ്യുന്നത് ചെയ്യും അല്ല കീ സൃഷ്ടിക്കുക.

എന്റെ % ഹാഷ് = ();
എന്റെ $മൂല്യം = $hash{ 'foo' };
$hash{ 'foo' } നിലവിലുണ്ടെങ്കിൽ "ഇത് പ്രിന്റ് ചെയ്യില്ല\n" എന്ന് അച്ചടിക്കുക;

ഒരു സബ്റൂട്ടീനിലേക്ക് $hash{ 'foo' } കൈമാറുന്നത് ഒരു പ്രത്യേക കേസായിരുന്നു, എന്നിരുന്നാലും. നിങ്ങൾക്ക് കഴിയുമായിരുന്നതിനാൽ
$_[0] എന്നതിലേക്ക് നേരിട്ട് അസൈൻ ചെയ്യുക, ആ അസൈൻമെന്റ് നടത്താൻ പേൾ തയ്യാറായിരിക്കണം, അങ്ങനെ അത് സൃഷ്ടിച്ചു
ഹാഷ് കീ സമയത്തിന് മുമ്പായി:

my_sub( $hash{ 'foo' } );
$hash{ 'foo' } നിലവിലുണ്ടെങ്കിൽ "ഇത് 5.004-ന് മുമ്പ് പ്രിന്റ് ചെയ്യും\n" എന്ന് പ്രിന്റ് ചെയ്യുക;

sub my_sub {
# $_[0] = 'ബാർ'; # നിങ്ങൾ ഇത് ചെയ്യുകയാണെങ്കിൽ ഹാഷ് കീ സൃഷ്ടിക്കുക
1;
}

എന്നിരുന്നാലും, Perl 5.004 മുതൽ, ഈ സാഹചര്യം ഒരു പ്രത്യേക സാഹചര്യമാണ്, പേൾ ഹാഷ് കീ സൃഷ്ടിക്കുന്നു
നിങ്ങൾ അസൈൻമെന്റ് ചെയ്യുമ്പോൾ മാത്രം:

my_sub( $hash{ 'foo' } );
$hash{ 'foo' } നിലവിലുണ്ടെങ്കിൽ "ഇത് 5.004\n ന് ശേഷവും പ്രിന്റ് ചെയ്യും";

sub my_sub {
$_[0] = 'ബാർ';
}

എന്നിരുന്നാലും, നിങ്ങൾക്ക് പഴയ പെരുമാറ്റം വേണമെങ്കിൽ (അതിനെക്കുറിച്ച് ശ്രദ്ധാപൂർവ്വം ചിന്തിക്കുക, കാരണം ഇത് വിചിത്രമാണ്
പാർശ്വഫലങ്ങൾ), പകരം നിങ്ങൾക്ക് ഒരു ഹാഷ് സ്ലൈസ് നൽകാം. Perl 5.004 ഇത് ഒരു പ്രത്യേകതയാക്കിയില്ല
കേസ്:

my_sub( @hash{ qw/foo/ } );

എങ്ങനെ കഴിയും I ഉണ്ടാക്കുക The പേൾ തുല്യമായ of a C ഘടന/C++ ക്ലാസ്/ഹാഷ് or ശ്രേണി of ഹാഷുകൾ or
അറേകൾ?
സാധാരണയായി ഒരു ഹാഷ് റെഫർ, ഒരുപക്ഷേ ഇതുപോലെ:

$റെക്കോർഡ് = {
NAME => "ജെയ്സൺ",
EMPNO => 132,
TITLE => "ഡെപ്യൂട്ടി പ്യൂൺ",
പ്രായം => 23,
ശമ്പളം => 37_000,
PALS => [ "നോർബർട്ട്", "റൈസ്", "ഫിനിയസ്"],
};

റഫറൻസുകൾ perlref, perlreftut എന്നിവയിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്. സങ്കീർണ്ണമായ ഡാറ്റ ഘടനകളുടെ ഉദാഹരണങ്ങൾ
perldsc, perllol എന്നിവയിൽ നൽകിയിരിക്കുന്നു. ഘടനകളുടെയും ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ക്ലാസുകളുടെയും ഉദാഹരണങ്ങളാണ്
perlootut ൽ.

എങ്ങനെ കഴിയും I ഉപയോഗം a സൂചന as a ഹാഷ് താക്കോൽ?
(ബ്രയാൻ ഡി ഫോയും ബെൻ മോറോയും സംഭാവന ചെയ്തത്)

ഹാഷ് കീകൾ സ്ട്രിംഗുകളാണ്, അതിനാൽ നിങ്ങൾക്ക് ഒരു റഫറൻസ് കീ ആയി ഉപയോഗിക്കാൻ കഴിയില്ല. നിങ്ങൾ ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ
അതായത്, perl റഫറൻസിനെ അതിന്റെ സ്ട്രിംഗ്ഫൈഡ് രൂപത്തിലേക്ക് മാറ്റുന്നു (ഉദാഹരണത്തിന്,
"ഹാഷ്(0xDEADBEEF)"). അവിടെ നിന്ന് നിങ്ങൾക്ക് സ്ട്രിംഗ്ഫൈഡിൽ നിന്ന് റഫറൻസ് തിരികെ ലഭിക്കില്ല.
ഫോം, കുറഞ്ഞത് സ്വന്തമായി ചില അധിക ജോലികൾ ചെയ്യാതെ.

പരാമർശിച്ച വേരിയബിൾ ആണെങ്കിലും ഹാഷിലെ എൻട്രി നിലനിൽക്കുമെന്ന് ഓർക്കുക
പരിധിക്ക് പുറത്താണ്, കൂടാതെ പിന്നീട് a അനുവദിക്കുന്നത് Perl-ന് പൂർണ്ണമായും സാധ്യമാണ്
ഒരേ വിലാസത്തിൽ വ്യത്യസ്ത വേരിയബിൾ. ഒരു പുതിയ വേരിയബിൾ ആകസ്മികമായി ഉണ്ടായേക്കാം എന്നാണ് ഇതിനർത്ഥം
പഴയതിന്റെ മൂല്യവുമായി ബന്ധപ്പെടുത്തുക.

നിങ്ങൾക്ക് Perl 5.10 അല്ലെങ്കിൽ അതിന് ശേഷമുള്ള പതിപ്പ് ഉണ്ടെങ്കിൽ, റഫറൻസിനെതിരെ ഒരു മൂല്യം സംഭരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
പിന്നീട് തിരയുന്നതിനായി, നിങ്ങൾക്ക് കോർ Hash::Util::Fieldhash മൊഡ്യൂൾ ഉപയോഗിക്കാം. ഇതും കൈകാര്യം ചെയ്യും
നിങ്ങൾ ഒന്നിലധികം ത്രെഡുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ കീകൾ പുനർനാമകരണം ചെയ്യുന്നു (എല്ലാ വേരിയബിളുകൾക്കും ഇത് കാരണമാകുന്നു
പുതിയ വിലാസങ്ങളിൽ വീണ്ടും അലോക്കേറ്റ് ചെയ്തു, അവയുടെ സ്ട്രിംഗ് മാറ്റുന്നു), മാലിന്യം ശേഖരിക്കുന്നു
പരാമർശിച്ച വേരിയബിൾ പരിധിക്ക് പുറത്താകുമ്പോൾ എൻട്രികൾ.

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

എങ്ങനെ കഴിയും I ചെക്ക് if a കീ നിലനിൽക്കുന്നു in a ബഹുനില ഹാഷ്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)

ആകസ്മികമായ ഓട്ടോവൈവിഫിക്കേഷൻ ഒഴിവാക്കുക എന്നതാണ് ഈ പ്രശ്നത്തിനുള്ള തന്ത്രം. നിങ്ങൾക്ക് പരിശോധിക്കണമെങ്കിൽ
മൂന്ന് കീകൾ ആഴത്തിൽ, നിങ്ങൾക്ക് ഇത് നിഷ്കളങ്കമായി പരീക്ഷിക്കാം:

എന്റെ % ഹാഷ്;
($hash{key1}{key2}{key3} നിലവിലുണ്ടെങ്കിൽ) {
...;
}

നിങ്ങൾ ആരംഭിച്ചത് പൂർണ്ണമായും ശൂന്യമായ ഹാഷിൽ ആണെങ്കിലും, അതിന് ശേഷം "നിലവിലുണ്ട്" എന്നതിലേക്കുള്ള കോൾ
"കീ3" പരിശോധിക്കാൻ ആവശ്യമായ ഘടന സൃഷ്ടിച്ചു:

%ഹാഷ് = (
'key1' => {
'key2' => {}
}
);

അതാണ് ഓട്ടോവൈവിഫിക്കേഷൻ. ചില വഴികളിലൂടെ നിങ്ങൾക്ക് ഇതിനെ മറികടക്കാം. ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം വെറുതെയാണ്
അതു നിർത്തൂ. ലെക്സിക്കൽ "ഓട്ടോവിവിഫിക്കേഷൻ" പ്രാഗ്മ CPAN-ൽ ലഭ്യമാണ്. ഇപ്പോൾ നിങ്ങൾ ചേർക്കരുത്
ഹാഷിലേക്ക്:

{
ഓട്ടോവൈവിഫിക്കേഷൻ ഇല്ല;
എന്റെ % ഹാഷ്;
($hash{key1}{key2}{key3} നിലവിലുണ്ടെങ്കിൽ) {
...;
}
}

CPAN-ലെ ഡാറ്റ:: ഡൈവർ മൊഡ്യൂളിന് നിങ്ങൾക്കും ഇത് ചെയ്യാൻ കഴിയും. അതിന്റെ "ഡൈവ്" സബ്റൂട്ടീന് നിങ്ങളോട് പറയാൻ കഴിയും
കീകൾ നിലവിലുണ്ടെങ്കിൽ മാത്രമല്ല, മൂല്യവും ലഭിക്കും:

ഡാറ്റ ഉപയോഗിക്കുക ::Diver qw(Dive);

my @exists = ഡൈവ്( \%hash, qw(key1 key2 key3) );
എങ്കിൽ (! @നിലവിലുണ്ട്) {
...; # കീകൾ നിലവിലില്ല
}
elsif(! നിർവചിക്കപ്പെട്ട $exists[0] ) {
...; # കീകൾ നിലവിലുണ്ട്, എന്നാൽ മൂല്യം അനിശ്ചിതമാണ്
}

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

if( check_hash( \%hash, qw(key1 key2 key3) ) ) {
...;
}

സബ് ചെക്ക്_ഹാഷ് {
എന്റെ ($ഹാഷ്, @കീകൾ) = @_;

@കീകൾ ഒഴികെ മടങ്ങുക;

എന്റെ $കീ (@കീകൾ) {
eval {നിലവിലില്ലെങ്കിൽ $hash->{$key} };
$hash = $hash->{$key};
}

തിരികെ വരുക;
}

എങ്ങനെ കഴിയും I തടയാൻ പുറമേ of അനാവശ്യമായ കീകൾ കടന്നു a ഹാഷ്?
പതിപ്പ് 5.8.0 മുതൽ, ഹാഷുകൾ ആകാം നിയന്ത്രിച്ചിരിക്കുന്നു നൽകിയിരിക്കുന്ന കീകളുടെ ഒരു നിശ്ചിത എണ്ണം. വേണ്ടിയുള്ള രീതികൾ
നിയന്ത്രിത ഹാഷുകൾ സൃഷ്ടിക്കുന്നതും കൈകാര്യം ചെയ്യുന്നതും Hash ::Util മൊഡ്യൂൾ കയറ്റുമതി ചെയ്യുന്നു.

ഡാറ്റ: പലവക

എങ്ങനെ do I കൈകാര്യം ചെയ്യുക ബൈനറി ഡാറ്റ ശരിയായി?
പേൾ ബൈനറി ക്ലീൻ ആണ്, അതിനാൽ ഇതിന് ബൈനറി ഡാറ്റ നന്നായി കൈകാര്യം ചെയ്യാൻ കഴിയും. എന്നിരുന്നാലും, വിൻഡോസിലോ ഡോസിലോ,
ബൈനറി ഫയലുകൾക്കായി നിങ്ങൾ "ബിൻമോഡ്" ഉപയോഗിക്കേണ്ടതുണ്ട്. ഇൻ
പൊതുവായി, നിങ്ങൾ ബൈനറി ഡാറ്റ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ആഗ്രഹിക്കുന്ന ഏത് സമയത്തും "binmode" ഉപയോഗിക്കണം.

പെർഫങ്കിലോ പെർലോപെന്റട്ടിലോ "ബിൻമോഡ്" കാണുക.

8-ബിറ്റ് ടെക്‌സ്‌ച്വൽ ഡാറ്റയെക്കുറിച്ച് നിങ്ങൾക്ക് ആശങ്കയുണ്ടെങ്കിൽ, perllocale കാണുക. നിങ്ങൾക്ക് കൈകാര്യം ചെയ്യണമെങ്കിൽ
മൾട്ടിബൈറ്റ് പ്രതീകങ്ങൾക്കൊപ്പം, എന്നിരുന്നാലും, ചില ഗൊച്ചകൾ ഉണ്ട്. റെഗുലർ എന്ന വിഭാഗം കാണുക
ഭാവങ്ങൾ.

എങ്ങനെ do I നിർണ്ണയിക്കുക എന്ന് a സ്കെയിലർ is a സംഖ്യ/മുഴുവൻ/പൂർണ്ണസംഖ്യ/ഫ്ലോട്ട്?
"NaN" അല്ലെങ്കിൽ "Infinity" പോലുള്ള IEEE നൊട്ടേഷനുകൾ നിങ്ങൾ ശ്രദ്ധിക്കുന്നില്ലെന്ന് കരുതുക
ഒരു സാധാരണ പദപ്രയോഗം ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു:

5.010 ഉപയോഗിക്കുക;

നൽകിയത് ($നമ്പർ) {
എപ്പോൾ ( /\D/ )
{"\thas non-digits" എന്ന് പറയുക; തുടരുക }
എപ്പോൾ ( /^\d+\z/ )
{ "\ഇത് ഒരു പൂർണ്ണ സംഖ്യ" എന്ന് പറയുക; തുടരുക }
എപ്പോൾ( /^-?\d+\z/)
{ "\ഇത് ഒരു പൂർണ്ണസംഖ്യ" എന്ന് പറയുക; തുടരുക }
എപ്പോൾ( /^[+-]?\d+\z/ )
{"\tis a +/- integer" എന്ന് പറയുക; തുടരുക }
എപ്പോൾ( /^-?(?:\d+\.?|\.\d)\d*\z/ )
{"\ഇതൊരു യഥാർത്ഥ സംഖ്യ" എന്ന് പറയുക; തുടരുക }
എപ്പോൾ( /^[+-]?(?=\.?\d)\d*\.?\d*(?:e[+-]?\d+)?\z/i)
{ പറയുക "\ഇത് ഒരു സി ഫ്ലോട്ട്" }
}

ടാസ്‌ക്കിനായി സാധാരണയായി ഉപയോഗിക്കുന്ന ചില മൊഡ്യൂളുകളും ഉണ്ട്. Scalar::Util (വിതരണം
5.8) നിർണ്ണയിക്കുന്നതിന് perl-ന്റെ ആന്തരിക പ്രവർത്തനമായ "looks_like_number"-ലേക്ക് ആക്സസ് നൽകുന്നു
ഒരു വേരിയബിൾ ഒരു സംഖ്യ പോലെ കാണുന്നുണ്ടോ എന്ന്. ഡാറ്റ:: ഡാറ്റ സാധൂകരിക്കുന്ന തരത്തിലുള്ള എക്സ്പോർട്ട് ഫംഗ്ഷനുകൾ
മുകളിലുള്ളതും മറ്റ് പതിവ് പദപ്രയോഗങ്ങളും ഉപയോഗിക്കുന്ന തരങ്ങൾ. മൂന്നാമതായി, Regexp:: Common ഉണ്ട്
വിവിധ തരത്തിലുള്ള സംഖ്യകളുമായി പൊരുത്തപ്പെടുന്നതിന് റെഗുലർ എക്സ്പ്രഷനുകൾ ഉണ്ട്. ആ മൂന്ന് മൊഡ്യൂളുകളാണ്
CPAN-ൽ നിന്ന് ലഭ്യമാണ്.

നിങ്ങളൊരു POSIX സിസ്റ്റത്തിലാണെങ്കിൽ, പരിവർത്തനം ചെയ്യുന്നതിനായി Perl "POSIX::strtod" ഫംഗ്‌ഷനെ പിന്തുണയ്ക്കുന്നു.
സ്ട്രിംഗുകൾ ഇരട്ടിയാക്കുന്നു (കൂടാതെ "POSIX::strtol" നീളമുള്ളവയ്ക്ക്). അതിന്റെ അർത്ഥശാസ്‌ത്രം ഒരു പരിധിവരെ
ബുദ്ധിമുട്ടാണ്, അതിനാൽ കൂടുതൽ സൗകര്യപ്രദമായ ആക്‌സസിനായി ഇവിടെ ഒരു "ഗെറ്റ്നം" റാപ്പർ ഫംഗ്‌ഷൻ ഉണ്ട്. ഈ
ഫംഗ്‌ഷൻ ഒരു സ്ട്രിംഗ് എടുത്ത് അത് കണ്ടെത്തിയ നമ്പർ നൽകുന്നു, അല്ലെങ്കിൽ ഇൻപുട്ടിനായി "undef"
സി ഫ്ലോട്ട്. "ഇസ്_ന്യൂമെറിക്" ഫംഗ്‌ഷൻ "ഗെറ്റ്നം" എന്നതിന്റെ മുൻഭാഗമാണ്, "ഇസ്
ഇതൊരു ഫ്ലോട്ടാണോ?"

ഉപ ഗെറ്റ്നം {
POSIX qw(strtod) ഉപയോഗിക്കുക;
എന്റെ $str = shift;
$str =~ s/^\s+//;
$str =~ s/\s+$//;
$! = 0;
my($num, $unparsed) = strtod($str);
എങ്കിൽ (($str eq '') || ($പാഴ്‌സ് ചെയ്യാത്തത് != 0) || $!) {
തിരികെ undef;
}
else {
തിരികെ $num;
}
}

സബ്_ന്യൂമെറിക് {defined getnum($_[0])}

അല്ലെങ്കിൽ നിങ്ങൾക്ക് പകരം CPAN-ലെ String ::Scanf മൊഡ്യൂൾ പരിശോധിക്കാം.

എങ്ങനെ do I സൂക്ഷിക്കുക നിര്ബന്ധംപിടിക്കുക ഡാറ്റ ഉടനീളം പ്രോഗ്രാം കോളുകൾ?
ചില പ്രത്യേക ആപ്ലിക്കേഷനുകൾക്കായി, നിങ്ങൾക്ക് DBM മൊഡ്യൂളുകളിൽ ഒന്ന് ഉപയോഗിക്കാം. AnyDBM_File കാണുക. കൂടുതൽ
പൊതുവേ, നിങ്ങൾ CPAN-ൽ നിന്നുള്ള FreezeThaw അല്ലെങ്കിൽ Storable മൊഡ്യൂളുകൾ പരിശോധിക്കണം. തുടങ്ങുന്ന
Perl 5.8-ൽ നിന്ന്, Storable എന്നത് സ്റ്റാൻഡേർഡ് ഡിസ്ട്രിബ്യൂഷന്റെ ഭാഗമാണ്. ഉപയോഗിക്കുന്ന ഒരു ഉദാഹരണം ഇതാ
സ്‌റ്റോറബിളിന്റെ "സ്റ്റോർ", "വീണ്ടെടുക്കുക" എന്നീ ഫംഗ്‌ഷനുകൾ:

Storable ഉപയോഗിക്കുക;
സ്റ്റോർ (\% ഹാഷ്, "ഫയൽ നാമം");

# പിന്നീട്...
$href = വീണ്ടെടുക്കുക("ഫയലിന്റെ പേര്"); # റഫറൻസ് മുഖേന
%hash = %{ വീണ്ടെടുക്കുക("ഫയലിന്റെ പേര്")}; # നേരിട്ട് ഹാഷിലേക്ക്

എങ്ങനെ do I അച്ചടിക്കുക പുറത്ത് or പകർത്തുക a ആവർത്തന ഡാറ്റ ഘടന?
CPAN-ലെ ഡാറ്റ::ഡമ്പർ മൊഡ്യൂൾ (അല്ലെങ്കിൽ Perl-ന്റെ 5.005 റിലീസ്) പ്രിന്റ് ഔട്ട് ചെയ്യാൻ മികച്ചതാണ്
ഡാറ്റ ഘടനകൾ. CPAN-ലെ സ്‌റ്റോറബിൾ മൊഡ്യൂൾ (അല്ലെങ്കിൽ Perl-ന്റെ 5.8 റിലീസ്), a
"dclone" എന്ന് വിളിക്കുന്ന ഫംഗ്‌ഷൻ അതിന്റെ ആർഗ്യുമെന്റ് ആവർത്തിച്ച് പകർത്തുന്നു.

Storable qw(dclone) ഉപയോഗിക്കുക;
$r2 = dclone($r1);

നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഏത് തരത്തിലുള്ള ഡാറ്റാ ഘടനയ്ക്കും $r1 ഒരു റഫറൻസായിരിക്കാം. അത് ആഴത്തിലുള്ളതായിരിക്കും
പകർത്തി. "dclone" റഫറൻസുകൾ എടുക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നതിനാൽ, നിങ്ങൾ അധിക വിരാമചിഹ്നങ്ങൾ ചേർക്കേണ്ടതുണ്ട്
നിങ്ങൾ പകർത്താൻ ആഗ്രഹിക്കുന്ന ഒരു ഹാഷ് അറേകൾ ഉണ്ടെങ്കിൽ.

%newhash = %{ dclone(\%oldhash) };

എങ്ങനെ do I നിര്വചിക്കുക രീതികൾ വേണ്ടി ഓരോ ക്ലാസ്/വസ്തു?
(ബെൻ മോറോ സംഭാവന ചെയ്തത്)

നിങ്ങൾക്ക് "UNIVERSAL" ക്ലാസ് ഉപയോഗിക്കാം (യൂണിവേഴ്സൽ കാണുക). എന്നിരുന്നാലും, ദയവായി വളരെ ശ്രദ്ധിക്കുക
ഇത് ചെയ്യുന്നതിന്റെ അനന്തരഫലങ്ങൾ പരിഗണിക്കുക: എല്ലാ ഒബ്ജക്റ്റിലേക്കും രീതികൾ ചേർക്കുന്നത് വളരെ സാധ്യതയുണ്ട്
ഉദ്ദേശിക്കാത്ത പ്രത്യാഘാതങ്ങൾ ഉണ്ടാകും. സാധ്യമെങ്കിൽ, നിങ്ങളുടെ എല്ലാ വസ്തുക്കളും ഉണ്ടായിരിക്കുന്നതാണ് നല്ലത്
ചില പൊതുവായ അടിസ്ഥാന ക്ലാസിൽ നിന്ന് അവകാശം നേടുക, അല്ലെങ്കിൽ പിന്തുണയ്ക്കുന്ന മൂസ് പോലുള്ള ഒരു ഒബ്ജക്റ്റ് സിസ്റ്റം ഉപയോഗിക്കുക
റോളുകൾ.

എങ്ങനെ do I പരിശോധിക്കുക a ക്രെഡിറ്റ് കാർഡ് ചെക്ക്സം?
CPAN-ൽ നിന്ന് ബിസിനസ്::ക്രെഡിറ്റ്കാർഡ് മൊഡ്യൂൾ നേടുക.

എങ്ങനെ do I പായ്ക്ക് ചെയ്യുക ശ്രേണികൾ of ഇരട്ടകൾ or ചങ്ങാടം വേണ്ടി XS കോഡ്?
CPAN-ലെ PGPLOT മൊഡ്യൂളിലെ arrays.h/arrays.c കോഡ് ഇത് ചെയ്യുന്നു. നിങ്ങൾ ഒരു ചെയ്യുകയാണെങ്കിൽ
ധാരാളം ഫ്ലോട്ട് അല്ലെങ്കിൽ ഇരട്ട പ്രോസസ്സിംഗ്, പകരം CPAN-ൽ നിന്നുള്ള PDL മൊഡ്യൂൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക--അത്
നമ്പർ ക്രഞ്ചിംഗ് എളുപ്പമാക്കുന്നു.

കാണുകhttp://search.cpan.org/dist/PGPLOT> കോഡിനായി.

AUTHOR ഒപ്പം പകർപ്പവകാശ

പകർപ്പവകാശം (സി) 1997-2010 ടോം ക്രിസ്റ്റ്യൻസെൻ, നഥാൻ ടോർക്കിംഗ്ടൺ, മറ്റ് രചയിതാക്കൾ എന്നിവരും സൂചിപ്പിച്ചു.
എല്ലാ അവകാശങ്ങളും നിക്ഷിപ്തം.

ഈ ഡോക്യുമെന്റേഷൻ സൗജന്യമാണ്; അതേ നിബന്ധനകൾക്ക് കീഴിൽ നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
പേർൾ തന്നെ.

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

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