PHPസ്കെയിലറും സംയോജിത ഡാറ്റാ തരങ്ങളും പിന്തുണയ്ക്കുന്നു. ഈ ലേഖനത്തിൽ, ഞങ്ങൾ സംയോജിത തരങ്ങളിലൊന്ന് ചർച്ച ചെയ്യും: അറേകൾ. കീ-വാല്യൂ ജോഡികളുടെ ക്രമീകരിച്ച സെറ്റായി ഓർഗനൈസുചെയ്ത ഡാറ്റ മൂല്യങ്ങളുടെ ഒരു ശേഖരമാണ് അറേ.
ഈ ലേഖനം ഒരു അറേ സൃഷ്ടിക്കുന്നതിനെക്കുറിച്ചും ഒരു അറേയിലേക്ക് ഘടകങ്ങൾ ചേർക്കുന്നതിനെക്കുറിച്ചും സംസാരിക്കുന്നു. അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്ന നിരവധി ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ഉണ്ട് PHPകാരണം അറേകൾ സാധാരണവും ഉപയോഗപ്രദവുമാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒന്നിലധികം ഇമെയിൽ വിലാസങ്ങളിലേക്ക് ഒരു ഇമെയിൽ അയയ്ക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഇമെയിൽ വിലാസങ്ങൾ ഒരു അറേയിൽ സംഭരിക്കുകയും തുടർന്ന് അറേയിലൂടെ ലൂപ്പ് ചെയ്യുകയും അറേയിൽ നിന്ന് എടുത്ത ഇമെയിൽ വിലാസത്തിലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കുകയും ചെയ്യാം.
ഇൻഡക്സ് ചെയ്തതും അനുബന്ധ ശ്രേണികളും
PHP-യിൽ രണ്ട് തരം അറേകളുണ്ട്: സൂചികയും അസോസിയേറ്റീവ്. ഒരു ഇൻഡക്സ് ചെയ്ത അറേയുടെ കീകൾ 0 മുതൽ ആരംഭിക്കുന്ന പൂർണ്ണസംഖ്യകളാണ്. നിങ്ങൾക്ക് അറേയിൽ ഒരു പ്രത്യേക സ്ഥാനം ആവശ്യമുള്ളപ്പോൾ സൂചികയിലുള്ള അറേകൾ ഉപയോഗിക്കുന്നു. അസോസിയേറ്റീവ് അറേകൾ ഒരു പട്ടികയുടെ രണ്ട് നിരകൾ പോലെയാണ് പ്രവർത്തിക്കുന്നത്. മൂല്യം (രണ്ടാമത്തെ നിര) ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന കീയാണ് ആദ്യ നിര.
PHPആന്തരികമായി എല്ലാ അറേകളും അസോസിയേറ്റീവ് അറേകളായി സംഭരിക്കുന്നു, അതിനാൽ അസോസിയേറ്റീവ്, ഇൻഡെക്സ്ഡ് അറേകൾ തമ്മിലുള്ള ഒരേയൊരു വ്യത്യാസം കീകൾ ദൃശ്യമാകുന്നു എന്നതാണ്. ചില ഫംഗ്ഷനുകൾ പ്രാഥമികമായി ഇൻഡെക്സ് ചെയ്ത അറേയ്ക്ക് വേണ്ടിയുള്ളതാണ്, കാരണം നിങ്ങളുടെ കീകൾ 0-ൽ ആരംഭിക്കുന്ന സീക്വൻഷ്യൽ പൂർണ്ണസംഖ്യകളാണെന്ന് അവർ അനുമാനിക്കുന്നു. രണ്ട് സാഹചര്യങ്ങളിലും, കീകൾ അദ്വിതീയമാണ് - അതായത്, കീ ആണെങ്കിലും, ഒരേ കീ ഉള്ള രണ്ട് ഘടകങ്ങൾ നിങ്ങൾക്ക് ഉണ്ടാകില്ല. ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ ഒരു പൂർണ്ണസംഖ്യയാണ്.
IN PHPഅറേകൾക്ക് അവയുടെ മൂലകങ്ങളുടെ ഒരു ആന്തരിക ക്രമം ഉണ്ട്, അത് കീകളിൽ നിന്നും മൂല്യങ്ങളിൽ നിന്നും സ്വതന്ത്രമാണ്, കൂടാതെ ഈ ആന്തരിക ക്രമത്തെ അടിസ്ഥാനമാക്കി അറേകളിൽ സഞ്ചരിക്കാൻ ഉപയോഗിക്കാവുന്ന ഫംഗ്ഷനുകളും ഉണ്ട്.
ഒരു അറേയിലെ ഘടകങ്ങൾ നിർവചിക്കുന്നു
സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ എലമെൻ്റ് കീ (ചിലപ്പോൾ സൂചിക എന്ന് വിളിക്കുന്നു) ഉപയോഗിച്ച് അറേ നാമം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു അറേയിൽ നിന്ന് നിർദ്ദിഷ്ട മൂല്യങ്ങൾ ആക്സസ് ചെയ്യാൻ കഴിയും:
$age["ഫ്രെഡ്"]; $ഷോകൾ;
കീ ഒരു സ്ട്രിംഗോ പൂർണ്ണസംഖ്യയോ ആകാം. സ്ട്രിംഗ് മൂല്യങ്ങളെ സംഖ്യകളായി (പൂജ്യം കൂടാതെ) പൂർണ്ണസംഖ്യകളായി കണക്കാക്കുന്നു. അങ്ങനെ, $അറേഒപ്പം $array['3']ഒരേ ഘടകത്തെ പരാമർശിക്കുക, പക്ഷേ $array['03']മറ്റൊരു ഘടകത്തെ സൂചിപ്പിക്കുന്നു. നെഗറ്റീവ് നമ്പറുകൾ കീകളായും ഉപയോഗിക്കാം, പക്ഷേ അവ അറേയുടെ അവസാനം മുതൽ സ്ഥാനങ്ങൾ വ്യക്തമാക്കുന്നില്ല. പേൾ.
ഉദ്ധരണികളിൽ കീ എഴുതേണ്ട ആവശ്യമില്ല. ഉദാഹരണത്തിന്, $array['Fred']പോലെ $അരറ്റ്.എന്നിരുന്നാലും, ഇത് നല്ല ശൈലിയായി കണക്കാക്കപ്പെടുന്നു PHPഎപ്പോഴും ഉദ്ധരണികൾ ഉപയോഗിക്കുക. സൂചിക ഉദ്ധരണികളില്ലാത്തതാണെങ്കിൽ, PHP സ്ഥിരാങ്കത്തിൻ്റെ മൂല്യം സൂചികയായി ഉപയോഗിക്കുന്നു:
നിർവ്വചിക്കുക("സൂചിക",5); എക്കോ $അറേ; // $array ["index"] അല്ല, $array തിരികെ നൽകും;
സൂചികയിൽ ഒരു നമ്പർ പകരം വയ്ക്കണമെങ്കിൽ, നിങ്ങൾ ഇത് ചെയ്യേണ്ടതുണ്ട്:
$age["Clone$number"]; // തിരികെ വരും, ഉദാഹരണത്തിന് $age["ക്ലോൺ5"];
എന്നിരുന്നാലും, ഇനിപ്പറയുന്ന സാഹചര്യത്തിൽ കീ ഉദ്ധരിക്കരുത്:
// തെറ്റായ പ്രിൻ്റ് "ഹലോ, $person["name"]"; "ഹലോ, $person["name"]" പ്രിൻ്റ് ചെയ്യുക; // ശരിയായ പ്രിൻ്റ് "ഹലോ, $person";
അറേകളിൽ ഡാറ്റ സംഭരിക്കുന്നു
നിങ്ങൾ ഒരു അറേയിൽ ഒരു മൂല്യം സംഭരിക്കാൻ ശ്രമിക്കുമ്പോൾ, അത് മുമ്പ് നിലവിലില്ലായിരുന്നുവെങ്കിൽ, അറേ സ്വയമേവ സൃഷ്ടിക്കപ്പെടും, എന്നാൽ നിർവചിച്ചിട്ടില്ലാത്ത ഒരു അറേയിൽ നിന്ന് ഒരു മൂല്യം വീണ്ടെടുക്കാൻ ശ്രമിക്കുമ്പോൾ, അറേ സൃഷ്ടിക്കപ്പെടില്ല. ഉദാഹരണത്തിന്:
// $വിലാസങ്ങൾ ഇതുവരെ നിർവചിച്ചിട്ടില്ല $വിലാസങ്ങൾ പ്രതിധ്വനിക്കുക; // ഒന്നും പ്രതിധ്വനിക്കുന്നില്ല $ വിലാസങ്ങൾ; // ഒന്നുമില്ല $വിലാസങ്ങൾ = " [ഇമെയിൽ പരിരക്ഷിതം]"; പ്രതിധ്വനി $വിലാസങ്ങൾ; // പ്രിൻ്റ് "അറേ"
ഒരു പ്രോഗ്രാമിൽ ഒരു അറേ സമാരംഭിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു ലളിതമായ അസൈൻമെൻ്റ് ഉപയോഗിക്കാം:
$വിലാസങ്ങൾ = " [ഇമെയിൽ പരിരക്ഷിതം]"; $വിലാസങ്ങൾ = " [ഇമെയിൽ പരിരക്ഷിതം]"; $വിലാസങ്ങൾ = " [ഇമെയിൽ പരിരക്ഷിതം]"; // ...
0-ൽ ആരംഭിക്കുന്ന പൂർണ്ണസംഖ്യ സൂചികകളുള്ള ഒരു സൂചിക അറേ ഞങ്ങൾ പ്രഖ്യാപിച്ചു.
അസോസിയേറ്റീവ് അറേ:
$വില["ഗാസ്കറ്റ്"] = 15.29; $വില["വീൽ"] = 75.25; $വില["ടയർ"] = 50.00; //...
ഒരു അറേ സമാരംഭിക്കുന്നതിനുള്ള ഒരു എളുപ്പമാർഗ്ഗം നിർമ്മാണം ഉപയോഗിക്കുക എന്നതാണ് അറേ(), അതിൻ്റെ ആർഗ്യുമെൻ്റുകളിൽ നിന്ന് ഒരു അറേ നിർമ്മിക്കുന്നു:
$വിലാസങ്ങൾ = അറേ(" [ഇമെയിൽ പരിരക്ഷിതം]", "[ഇമെയിൽ പരിരക്ഷിതം]", "[ഇമെയിൽ പരിരക്ഷിതം]");
ഉപയോഗിച്ച് ഒരു അസോസിയേറ്റീവ് അറേ സൃഷ്ടിക്കാൻ അറേ(),ഉപയോഗിക്കുക => മൂല്യങ്ങളിൽ നിന്ന് സൂചികകളെ വേർതിരിക്കുന്ന ചിഹ്നം:
$price = അറേ("Gasket" => 15.29, "Wheel" => 75.25, "Tire" => 50.00);
സ്പെയ്സുകളുടെയും വിന്യാസത്തിൻ്റെയും ഉപയോഗം ശ്രദ്ധിക്കുക. ഞങ്ങൾക്ക് കോഡ് ഗ്രൂപ്പുചെയ്യാനാകും, പക്ഷേ അത് വ്യക്തമല്ല:
$വില = അറേ("ഗാസ്കറ്റ്"=>15.29,"വീൽ"=>75.25,"ടയർ"=>50.00);
ഒരു ശൂന്യമായ അറേ സൃഷ്ടിക്കുന്നതിന്, നിങ്ങൾ നിർമ്മാണത്തെ വിളിക്കേണ്ടതുണ്ട് അറേ()വാദങ്ങളില്ലാതെ:
$വിലാസങ്ങൾ = അറേ();
നിങ്ങൾക്ക് ഒരു അറേയിൽ ഒരു ആരംഭ കീയും തുടർന്ന് മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റും വ്യക്തമാക്കാം. മൂല്യങ്ങൾ അറേയിൽ നൽകിയിട്ടുണ്ട്, കീയിൽ നിന്ന് ആരംഭിച്ച് വർദ്ധിക്കുന്നു:
$days = അറേ(1 => "തിങ്കൾ", "ചൊവ്വ", "ബുധൻ", "വ്യാഴം", "വെള്ളി", "ശനി", "ഞായർ"); // 2 ചൊവ്വാഴ്ച, 3 ബുധനാഴ്ച, മുതലായവ.
ആരംഭ സൂചിക ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ, തുടർന്നുള്ള സൂചികകൾ പൂർണ്ണസംഖ്യകളായി മാറുന്നു, 0 മുതൽ ആരംഭിക്കുന്നു. അതിനാൽ ഇനിപ്പറയുന്ന കോഡ് ഒരു പിശകായിരിക്കാം:
$whoops = അറേ("വെള്ളിയാഴ്ച" => "കറുപ്പ്", "തവിട്ട്", "പച്ച"); // $whoops = അറേ ("വെള്ളിയാഴ്ച" => "കറുപ്പ്", 0 => "തവിട്ട്", 1 => "പച്ച");
ഒരു അറേയുടെ അവസാനം ഒരു പുതിയ ഘടകം ചേർക്കുന്നു
നിലവിലുള്ള ഒരു സൂചികയിലുള്ള അറേയുടെ അവസാനം ഒന്നിലധികം മൂല്യങ്ങൾ ചേർക്കുന്നതിന്, വാക്യഘടന ഉപയോഗിക്കുക:
$ഫാമിലി = അറേ("ഫ്രെഡ്", "വിൽമ"); // $family = "Fred" $family = "പെബിൾസ്"; // $family = "പെബിൾസ്"
അറേ സൂചികകൾ സംഖ്യകളാണെന്ന് ഈ നിർമ്മിതി അനുമാനിക്കുകയും 0-ൽ ആരംഭിക്കുന്ന അടുത്ത ലഭ്യമായ സംഖ്യാ സൂചിക മൂലകത്തിന് നൽകുകയും ചെയ്യുന്നു. PHPഒരു മുന്നറിയിപ്പ് നൽകാതെ തന്നെ സംഖ്യാ സൂചികകളുള്ള (0 മുതൽ ആരംഭിക്കുന്ന) പുതിയ ഘടകങ്ങൾ ചേർക്കും:
$person = array("name" => "Fred"); // $person["name"] = "Fred"; $person = "വിൽമ"; // $person = "വിൽമ"
ഈ ഘട്ടത്തിൽ, PHP-യിലെ അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിൻ്റെ ആമുഖ ഭാഗം ഞങ്ങൾ പൂർത്തിയാക്കും. അടുത്ത ലേഖനത്തിൽ നിങ്ങളെ കാണാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.
ഒരു അറേയിലേക്ക് ഘടകങ്ങൾ ചേർക്കുന്നു
അറേ നിലവിലുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അതിൽ അധിക ഘടകങ്ങൾ ചേർക്കാൻ കഴിയും. ഒരു സ്ട്രിംഗിലേക്കോ നമ്പറിലേക്കോ ഒരു മൂല്യം അസൈൻ ചെയ്യുന്നതുപോലെ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ (തുല്യ ചിഹ്നം) ഉപയോഗിച്ചാണ് ഇത് നേരിട്ട് ചെയ്യുന്നത്. ഈ സാഹചര്യത്തിൽ, ചേർത്ത മൂലകത്തിൻ്റെ കീ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതില്ല, എന്നാൽ ഏത് സാഹചര്യത്തിലും, അറേ ആക്സസ് ചെയ്യുമ്പോൾ സ്ക്വയർ ബ്രാക്കറ്റുകൾ ആവശ്യമാണ്. $List-ലേക്ക് രണ്ട് പുതിയ ഘടകങ്ങൾ ചേർത്ത് ഞങ്ങൾ എഴുതുന്നു:
$ലിസ്റ്റ് = "പിയേഴ്സ്";
$ലിസ്റ്റ് = "തക്കാളി";
കീ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഓരോ ഘടകവും നിലവിലുള്ള അറേയിലേക്ക് ചേർക്കുകയും അടുത്ത ഓർഡിനൽ നമ്പർ ഉപയോഗിച്ച് സൂചികയിലാക്കുകയും ചെയ്യും. 1, 2, 3 സൂചികകളുള്ള മുൻ വിഭാഗത്തിൽ നിന്ന് ഞങ്ങൾ പുതിയ ഘടകങ്ങൾ അറേയിലേക്ക് ചേർക്കുകയാണെങ്കിൽ, പിയേഴ്സിന് സൂചിക 4 ഉണ്ടായിരിക്കും, തക്കാളിക്ക് സൂചിക 5 ഉണ്ടായിരിക്കും. നിങ്ങൾ ഒരു സൂചിക വ്യക്തമായി വ്യക്തമാക്കുമ്പോൾ, അതിനുള്ള മൂല്യം ഇതിനകം നിലവിലുണ്ട്, ആ സ്ഥലത്ത് നിലവിലുള്ള മൂല്യം നഷ്ടപ്പെടുകയും പുതിയൊരെണ്ണം ഉപയോഗിച്ച് പകരം വയ്ക്കുകയും ചെയ്യും:
$ലിസ്റ്റ് = "പിയേഴ്സ്";
$ലിസ്റ്റ് = "തക്കാളി";
ഇപ്പോൾ സൂചിക 4 ഉള്ള മൂലകത്തിൻ്റെ മൂല്യം "തക്കാളി" ആണ്, "ഓറഞ്ച്" എന്ന മൂലകം ഇനി ഇല്ല. നിലവിലുള്ള ഏതെങ്കിലും ഡാറ്റ പുനരാലേഖനം ചെയ്യാൻ നിങ്ങൾ പ്രത്യേകമായി ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, ഒരു അറേയിലേക്ക് ഘടകങ്ങൾ ചേർക്കുമ്പോൾ ഒരു കീ വ്യക്തമാക്കരുതെന്ന് ഞാൻ ഉപദേശിക്കുന്നു. എന്നിരുന്നാലും, സ്ട്രിംഗുകൾ സൂചികകളായി ഉപയോഗിക്കുകയാണെങ്കിൽ, മൂല്യങ്ങൾ നഷ്ടപ്പെടാതിരിക്കാൻ കീകൾ വ്യക്തമാക്കണം.
soups.php സ്ക്രിപ്റ്റ് മാറ്റിയെഴുതി അറേയിലേക്ക് പുതിയ ഘടകങ്ങൾ ചേർക്കാൻ ഞങ്ങൾ ശ്രമിക്കും. ആദ്യം അറേയുടെ ഒറിജിനൽ എലമെൻ്റുകളും പിന്നീട് ചേർത്തവയ്ക്കൊപ്പം യഥാർത്ഥ ഘടകങ്ങളും പ്രിൻ്റ് ചെയ്യുന്നതിലൂടെ, സംഭവിച്ച മാറ്റങ്ങൾ നമുക്ക് എളുപ്പത്തിൽ കാണാൻ കഴിയും. strlen() ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗിൻ്റെ നീളം (അതിൽ അടങ്ങിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ എണ്ണം) കണ്ടെത്താൻ കഴിയുന്നതുപോലെ, കൗണ്ട്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം നിർണ്ണയിക്കാനും എളുപ്പമാണ്:
$HowMany = കൗണ്ട് ($Array);
- ഒരു ടെക്സ്റ്റ് എഡിറ്ററിൽ soups.php ഫയൽ തുറക്കുക.
- അറേ() ഫംഗ്ഷൻ ഉപയോഗിച്ച് അറേ ആരംഭിച്ച ശേഷം, ഇനിപ്പറയുന്ന എൻട്രി ചേർക്കുക: $HowMany = കൗണ്ട് ($ സൂപ്പുകൾ);
- അറേയിലേക്ക് മൂന്ന് അധിക ഘടകങ്ങൾ ചേർക്കുക. $Soups["വ്യാഴം"] = "ചിക്കൻ നൂഡിൽ";
- അറേയിലെ ഘടകങ്ങൾ എണ്ണി ഈ മൂല്യം പ്രിൻ്റ് ചെയ്യുക. $HowManyNow = കൗണ്ട് ($ സൂപ്പുകൾ);
- സ്ക്രിപ്റ്റ് സംരക്ഷിക്കുക (ലിസ്റ്റിംഗ് 7.2), അത് സെർവറിലേക്ക് അപ്ലോഡ് ചെയ്ത് ബ്രൗസറിൽ പരീക്ഷിക്കുക (ചിത്രം.).
പ്രിൻ്റ് ("അറേയിൽ $HowMany ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
$Sups അറേയിൽ എത്ര ഘടകങ്ങൾ ഉണ്ടെന്ന് കൗണ്ട്() ഫംഗ്ഷൻ നിർണ്ണയിക്കും. ഒരു വേരിയബിളിന് ഈ മൂല്യം നൽകുന്നതിലൂടെ, അത് പ്രിൻ്റ് ചെയ്യാൻ കഴിയും.
$Soups["വെള്ളിയാഴ്ച"] = "തക്കാളി";
$Soups["ശനി"] = "ക്രീം ഓഫ് ബ്രോക്കോളി";
പ്രിൻ്റ് ("അറേയിൽ ഇപ്പോൾ $HowManyNow ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
ലിസ്റ്റിംഗ് 7.2 ഉചിതമായ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഓരോ ഘടകത്തിനും ഒരു മൂല്യം നൽകിക്കൊണ്ട് നിങ്ങൾക്ക് ഒരു സമയം ഒരു ഘടകം നേരിട്ട് ഒരു അറേയിലേക്ക് ചേർക്കാൻ കഴിയും. ഒരു അറേയിൽ എത്ര ഘടകങ്ങൾ ഉണ്ടെന്ന് കണ്ടെത്താൻ കൗണ്ട്() ഫംഗ്ഷൻ ഉപയോഗിക്കാം.
1
2
3
4
5 6 $സൂപ്പുകൾ = അറേ(
7 "തിങ്കൾ"=>"ക്ലാം ചൗഡർ",
8 "ചൊവ്വ"=>"വൈറ്റ് ചിക്കൻ ചില്ലി",
9 "ബുധൻ"=>"വെജിറ്റേറിയൻ");
11 പ്രിൻ്റ് ("അറേയിൽ $HowMany അടങ്ങിയിരിക്കുന്നു
ഘടകങ്ങൾ.
\n");
12 $സൂപ്പുകൾ["വ്യാഴം"] = "ചിക്കൻ നൂഡിൽ";
13 $സൂപ്പുകൾ["വെള്ളിയാഴ്ച"] = "തക്കാളി";
14 $സൂപ്പുകൾ["ശനി"] = "ക്രീം ഓഫ്
ബ്രോക്കോളി";
15 $HowManyNow = കൗണ്ട് ($ സൂപ്പുകൾ);
16 പ്രിൻ്റ് ("അറേയിൽ ഇപ്പോൾ അടങ്ങിയിരിക്കുന്നു
$HowManyNow ഘടകം.
\n");
17 ?>
18
19
PHP 4.0 ഒരു പുതിയ സവിശേഷത അവതരിപ്പിച്ചു, അത് ഒരു അറേ മറ്റൊന്നിലേക്ക് ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ പ്രവർത്തനത്തെ അറേകളുടെ ലയനം അല്ലെങ്കിൽ സംയോജനം എന്നും വിളിക്കാം. array_merge() ഫംഗ്ഷനെ ഇനിപ്പറയുന്ന രീതിയിൽ വിളിക്കുന്നു:
$NewArray = array_merge($OneArray, $TwoArray);
PHP 4.0 ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഒരു സെർവറിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെങ്കിൽ, ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് soups.php പേജ് മാറ്റിയെഴുതാം.
രണ്ട് അറേകൾ ലയിപ്പിക്കുന്നു
- soups.php ഫയൽ ഇതിനകം തുറന്നിട്ടില്ലെങ്കിൽ ഒരു ടെക്സ്റ്റ് എഡിറ്ററിൽ തുറക്കുക.
- $Sups അറേ ആരംഭിച്ച ശേഷം, അതിൻ്റെ ഘടകങ്ങൾ എണ്ണി ഫലം പ്രിൻ്റ് ചെയ്യുക. $HowMany = കൗണ്ട് ($ സൂപ്പുകൾ);
- രണ്ട് അറേകൾ ഒന്നായി സംയോജിപ്പിക്കുക. $TheSoups = array_merge($Soups, $Soups2);
- പുതിയ അറേയുടെ ഘടകങ്ങൾ എണ്ണി ഫലം പ്രിൻ്റ് ചെയ്യുക. $HowMany3 = എണ്ണം ($TheSoups);
- PHP ഉം HTML പ്രമാണവും അടയ്ക്കുക. ?>
- ഫയൽ സംരക്ഷിക്കുക (ലിസ്റ്റിംഗ് 7.3), അത് സെർവറിലേക്ക് അപ്ലോഡ് ചെയ്ത് ബ്രൗസറിൽ പരീക്ഷിക്കുക (ചിത്രം).
പ്രിൻ്റ് ("$Sups അറേയിൽ $HowMany ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
- രണ്ടാമത്തെ അറേ സൃഷ്ടിക്കുക, അതിൻ്റെ ഘടകങ്ങൾ എണ്ണുക, ഫലം പ്രിൻ്റ് ചെയ്യുക.
"വ്യാഴം"=>"ചിക്കൻ നൂഡിൽ",
"വെള്ളിയാഴ്ച"=>"തക്കാളി",
"ശനി"=>"ക്രീം ഓഫ് ബ്രോക്കോളി");
$HowMany2 = എണ്ണം ($Soups2);
പ്രിൻ്റ് ("$Soups2 അറേയിൽ $HowMany2 ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
അറേകൾ ഈ ക്രമത്തിലാണ് ക്രമീകരിച്ചിരിക്കുന്നതെന്ന് ഉറപ്പാക്കുക ($Soups, തുടർന്ന് $Soups2), അതായത്, വ്യാഴം, വെള്ളി എന്നിവയുടെ ഘടകങ്ങൾ ബുധനാഴ്ചയിലെ തിങ്കളാഴ്ചകളിലെ ഘടകങ്ങളിലേക്ക് ചേർക്കണം, തിരിച്ചും അല്ല.
പ്രിൻ്റ് ("$TheSoups അറേയിൽ അടങ്ങിയിരിക്കുന്നു
-$HowMany3 ഘടകങ്ങൾ.
\n");
![](https://i0.wp.com/weblibrary.biz/bimages/php/img49.gif)
ലിസ്റ്റിംഗ് 7.3 Array_merge() ഫംഗ്ഷൻ പുതിയതാണ്. അറേകളിൽ പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിരിക്കുന്ന PHP 4.0-ലെ നിരവധി അധിക സവിശേഷതകളിൽ ഒന്നാണിത്. അറേകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ധാരാളം സമയം ലാഭിക്കാം.
1
2
3
4
5 6 $സൂപ്പുകൾ = അറേ!
7 "തിങ്കൾ"=>"ക്ലാം ചൗഡർ",
"ചൊവ്വ"=>"വൈറ്റ് ചിക്കൻ ചില്ലി",
8 "ബുധൻ"=>"വെജിറ്റേറിയൻ"
9);
10 $HowMany = കൗണ്ട് ($ സൂപ്പുകൾ);
11 പ്രിൻ്റ് ("$Sups അറേയിൽ $HowMany ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
12 $Sups2 = അറേ(
13 "വ്യാഴം"=>"ചിക്കൻ നൂഡിൽ",
14 "വെള്ളിയാഴ്ച"=>"തക്കാളി",
15 "ശനി"=>"ക്രീം ഓഫ് ബ്രോക്കോളി"
16); .
17 $HowMany2 = എണ്ണം ($Soups2);
18 പ്രിൻ്റ് ("$Soups2 അറേയിൽ $HowMany2 ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
19 $TbeSoupe = array_merge($Soups, $Soups2);
20 $HowMany3 = എണ്ണം ($TheSoups) ;
21 പ്രിൻ്റ് ("$TheSoups അറേയിൽ .$HowMany3 ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
\n");
22 ?> "
23
24
ഒരു അറേയിലേക്ക് നേരിട്ട് ഘടകങ്ങൾ ചേർക്കുമ്പോൾ ശ്രദ്ധിക്കുക. ഇത് ഇതുപോലെ ശരിയായി ചെയ്തു: $Ar ray = "ഇത് ചേർക്കുക"; iyai$Aggau = "ഇത് ചേർക്കുക";, എന്നാൽ ഇത് ഇതുപോലെ ശരിയാണ്: $Aggau = "ഇത് ചേർക്കുക";. നിങ്ങൾ പരാൻതീസിസുകൾ ഇടാൻ മറന്നാൽ, ചേർത്ത മൂല്യം നിലവിലുള്ള അറേയെ നശിപ്പിക്കും, അത് ഒരു ലളിതമായ സ്ട്രിംഗോ നമ്പറോ ആക്കി മാറ്റും.
അറേകളിൽ പ്രവർത്തിക്കുന്നതിന് PHP 4.0 ന് നിരവധി പുതിയ ഫംഗ്ഷനുകൾ ഉണ്ട്. അവയെല്ലാം പുസ്തകത്തിൽ ചർച്ച ചെയ്യപ്പെടുന്നില്ല. എന്നിരുന്നാലും, ഈ വിഷയത്തെക്കുറിച്ചുള്ള പൂർണ്ണമായ വിവരങ്ങൾ PHP ഭാഷാ മാനുവലിൽ അടങ്ങിയിരിക്കുന്നു, അത് PHP വെബ്സൈറ്റിൽ കാണാം. നിങ്ങളുടെ സെർവർ PHP 3.x ആണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, PHP 4.0-ന് മാത്രമുള്ള പുതിയ സവിശേഷതകൾ ഉപയോഗിക്കാതിരിക്കാൻ ശ്രദ്ധിക്കുക.
ഒരു അറേയിൽ മൂല്യങ്ങൾ എഴുതാനുള്ള വഴികൾ നോക്കാം. നിലവിലുള്ള അറേയിൽ മൂല്യങ്ങൾ വ്യക്തമായി സജ്ജീകരിച്ച് പരിഷ്ക്കരിക്കാൻ കഴിയും. ഒരു അറേയ്ക്ക് മൂല്യങ്ങൾ നൽകിയാണ് ഇത് ചെയ്യുന്നത്.
ഒരു അറേ എലമെൻ്റിന് ഒരു മൂല്യം നൽകുന്നതിൻ്റെ പ്രവർത്തനം, ഒരു വേരിയബിളിന് ഒരു മൂല്യം നൽകുന്നതിൻ്റെ പ്രവർത്തനത്തിന് തുല്യമാണ്, അറേ വേരിയബിളിൻ്റെ പേരിന് ശേഷം ചേർക്കുന്ന സ്ക്വയർ ബ്രാക്കറ്റുകൾ () ഒഴികെ. മൂലകത്തിൻ്റെ സൂചിക/കീ ചതുര ബ്രാക്കറ്റുകളിൽ സൂചിപ്പിച്ചിരിക്കുന്നു. സൂചിക/കീ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, PHP സ്വയമേവ ആളില്ലാത്ത ചെറിയ സംഖ്യാ സൂചിക തിരഞ്ഞെടുക്കും.
"പൂജ്യം", 1 => "ഒന്ന്"); $my_arr = "രണ്ട്"; $my_arr = "മൂന്ന്"; var_dump ($my_arr); സൂചിക/കീ $my_arr = "നാല്" വ്യക്തമാക്കാതെയുള്ള നിയമനം; $my_arr = "അഞ്ച്"; പ്രതിധ്വനി "
"; var_dump($my_arr); ?>
ഒരു നിർദ്ദിഷ്ട മൂല്യം മാറ്റുന്നതിന്, നിലവിലുള്ള ഒരു ഘടകത്തിന് നിങ്ങൾ ഒരു പുതിയ മൂല്യം നൽകുക. ഒരു അറേയുടെ ഏതെങ്കിലും ഘടകം അതിൻ്റെ സൂചിക/കീ ഉപയോഗിച്ച് നീക്കം ചെയ്യാനോ അറേ തന്നെ പൂർണ്ണമായും നീക്കം ചെയ്യാനോ, unset() ഫംഗ്ഷൻ ഉപയോഗിക്കുക:
ശ്രദ്ധിക്കുക: മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഒരു കീ വ്യക്തമാക്കാതെ ഒരു അറേയിലേക്ക് ഒരു ഘടകം ചേർത്താൽ, PHP സ്വയമേവ 1 വർദ്ധിച്ച മുൻ പൂർണ്ണസംഖ്യ കീ മൂല്യം ഉപയോഗിക്കും. ഇതുവരെ അറേയിൽ പൂർണ്ണസംഖ്യ സൂചികകൾ ഇല്ലെങ്കിൽ, കീ 0 ആയിരിക്കും (പൂജ്യം).
കീയുടെ ഏറ്റവും വലിയ പൂർണ്ണസംഖ്യ മൂല്യം എന്നത് ശ്രദ്ധിക്കുക ഇപ്പോൾ അറേയിൽ ഉണ്ടായിരിക്കണമെന്നില്ല, ഇത് അറേ മൂലകങ്ങളുടെ നീക്കം മൂലമാകാം. ഘടകങ്ങൾ നീക്കം ചെയ്തതിനുശേഷം, അറേ വീണ്ടും സൂചികയിലാക്കില്ല. ഇത് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഇനിപ്പറയുന്ന ഉദാഹരണം എടുക്കാം:
"; print_r($my_arr); // ഘടകം ചേർക്കുക (പുതിയ കീ 0-ന് പകരം 3 ആയിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക). $my_arr = 6; echo "
"; print_r($my_arr); // reindexing ചെയ്യുക: $my_arr = array_values($my_arr); $my_arr = 7; echo "
"; print_r($my_arr); ?>
ഈ ഉദാഹരണം രണ്ട് പുതിയ ഫംഗ്ഷനുകൾ ഉപയോഗിച്ചു, print_r(), array_values(). array_values() ഫംഗ്ഷൻ ഒരു ഇൻഡക്സ് ചെയ്ത അറേ നൽകുന്നു (റിട്ടേൺ ചെയ്ത അറേയെ സംഖ്യാ സൂചികകൾ ഉപയോഗിച്ച് വീണ്ടും സൂചികയാക്കുന്നു), കൂടാതെ print_r ഫംഗ്ഷൻ var_dump പോലെ പ്രവർത്തിക്കുന്നു, പക്ഷേ അറേകൾ കൂടുതൽ വായിക്കാനാകുന്ന രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുന്നു.
ഇപ്പോൾ നമുക്ക് അറേകൾ സൃഷ്ടിക്കുന്നതിനുള്ള മൂന്നാമത്തെ വഴി നോക്കാം:
ഒരു അറേ സൃഷ്ടിക്കുന്നതിനുള്ള മൂന്നാമത്തെ മാർഗം ഉദാഹരണം കാണിച്ചു. $weekdays അറേ ഇതുവരെ സൃഷ്ടിച്ചിട്ടില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും. എന്നിരുന്നാലും, $weekdays വേരിയബിൾ ഇതിനകം തന്നെ സൃഷ്ടിക്കുകയും ഒരു മൂല്യം ഉൾക്കൊള്ളുകയും ചെയ്തിട്ടുണ്ടെങ്കിൽ, സ്ക്രിപ്റ്റിൽ നിന്ന് അപ്രതീക്ഷിത ഫലങ്ങൾ ഉണ്ടാക്കിയേക്കാം എന്നതിനാൽ, ഇത്തരത്തിലുള്ള അറേ സൃഷ്ടിക്കൽ ശുപാർശ ചെയ്യുന്നില്ല.
ഒരു വേരിയബിൾ ഒരു അറേ ആണോ എന്ന് നിങ്ങൾക്ക് സംശയമുണ്ടെങ്കിൽ, is_array ഫംഗ്ഷൻ ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, പരിശോധന ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യാം:
"; $no = "റെഗുലർ സ്ട്രിംഗ്"; echo is_array($no) ? "Array" : "ഒരു array അല്ല"; ?>
പിഎച്ച്പിയിൽ അറേകൾ പരിവർത്തനം ചെയ്യുന്നതിന് നിരവധി ഫംഗ്ഷനുകളും ഓപ്പറേറ്റർമാരും ഉണ്ട്: അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഫംഗ്ഷനുകളുടെ ശേഖരം
PHP ഉപയോഗിച്ച് ഒരു അറേയിലേക്ക് ഒരു അറേ ചേർക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട്, അവയെല്ലാം ചില സന്ദർഭങ്ങളിൽ ഉപയോഗപ്രദമാകും.
"ഓപ്പറേറ്റർ +"
ഇത് ലളിതവും എന്നാൽ വഞ്ചനാപരവുമായ മാർഗമാണ്:
$c = $a + $b
ഈ രീതിയിൽ, $a അറേയിൽ ഇതിനകം ഇല്ലാത്ത കീകൾ മാത്രമേ ചേർക്കൂ. ഈ സാഹചര്യത്തിൽ, അറേയുടെ അവസാനം ഘടകങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു.
അതായത്, $b എന്ന അറേയിൽ നിന്നുള്ള കീ $a അറേയിൽ ഇല്ലെങ്കിൽ, ഈ കീ ഉള്ള ഒരു ഘടകം തത്ഫലമായുണ്ടാകുന്ന അറേയിലേക്ക് ചേർക്കും.
$a അറേയിൽ ഇതിനകം അത്തരമൊരു കീ ഉള്ള ഒരു ഘടകം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അതിൻ്റെ മൂല്യം മാറ്റമില്ലാതെ തുടരും.
മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നിബന്ധനകളുടെ സ്ഥലങ്ങൾ മാറ്റുന്നത് തുകയെ മാറ്റുന്നു: $a + $b != $b + $a - ഇത് ഓർമ്മിക്കേണ്ടതാണ്.
ഇപ്പോൾ ഇത് വ്യക്തമാക്കുന്നതിന് കൂടുതൽ വിശദമായ ഒരു ഉദാഹരണം ഇതാ:
$arr1 = ["a" => 1, "b" => 2]; $arr2 = ["b" => 3, "c" => 4]; var_export ($arr1 + $arr2); //അറേ (// "a" => 1, // "b" => 2, // "c" => 4, //) var_export($arr2 + $arr1); //അറേ (// "b" => 3, // "c" => 4, // "a" => 1, //)
array_merge() ഫംഗ്ഷൻ
നിങ്ങൾക്ക് ഈ ഫംഗ്ഷൻ ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിക്കാം:
$ഫലം = array_merge($arr1, $arr2)
ഇത് സംഖ്യാ സൂചികകൾ പുനഃസജ്ജമാക്കുകയും സ്ട്രിംഗുകൾ മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു. സംഖ്യാ സൂചികകൾ ഉപയോഗിച്ച് രണ്ടോ അതിലധികമോ അറേകൾ സംയോജിപ്പിക്കുന്നതിന് മികച്ചത്:
ഇൻപുട്ട് അറേകൾക്ക് ഒരേ സ്ട്രിംഗ് കീകൾ ഉണ്ടെങ്കിൽ, തുടർന്നുള്ള ഓരോ മൂല്യവും മുമ്പത്തേതിന് പകരം വയ്ക്കും. എന്നിരുന്നാലും, അറേകൾക്ക് സമാന സംഖ്യാ കീകൾ ഉണ്ടെങ്കിൽ, അവസാനം സൂചിപ്പിച്ച മൂല്യം യഥാർത്ഥ മൂല്യത്തെ മാറ്റിസ്ഥാപിക്കില്ല, പക്ഷേ അറേയുടെ അവസാനത്തിലേക്ക് ചേർക്കും.
array_merge_recursive ഫംഗ്ഷൻ
array_merge പോലെ തന്നെ ചെയ്യുന്നു, അറേയുടെ ഓരോ ശാഖയിലൂടെയും ആവർത്തിച്ച് കടന്നുപോകുകയും കുട്ടികളുമായി അത് ചെയ്യുകയും ചെയ്യുന്നു.
array_replace() ഫംഗ്ഷൻ
പാസാക്കിയ മറ്റ് അറേകളുടെ ഘടകങ്ങൾ ഉപയോഗിച്ച് അറേ എലമെൻ്റുകൾ മാറ്റിസ്ഥാപിക്കുന്നു.
array_replace_recursive() ഫംഗ്ഷൻ
array_replace പോലെ തന്നെ എന്നാൽ അറേയുടെ എല്ലാ ശാഖകളും പ്രോസസ്സ് ചെയ്യുന്നു.
അറേ_പാഡ്
അറേയിലേക്ക് നിരവധി ഘടകങ്ങൾ ചേർക്കുന്നു.
വാക്യഘടന:
Array array_pad(അറേ ഇൻപുട്ട്, int pad_size, mixed pad_value)
array_pad() ഫംഗ്ഷൻ, pad_values ഉള്ള ഘടകങ്ങൾ ചേർത്തിട്ടുള്ള ഇൻപുട്ട് അറേയുടെ ഒരു പകർപ്പ് നൽകുന്നു, അങ്ങനെ ഫലമായുണ്ടാകുന്ന അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം pad_size ആയിരിക്കും.
pad_size>0 ആണെങ്കിൽ, ഘടകങ്ങൾ അറേയുടെ അവസാനം ചേർക്കും, എങ്കിൽ<0 - то в начало.
pad_size-ൻ്റെ മൂല്യം യഥാർത്ഥ ഇൻപുട്ട് അറേയിലെ ഘടകങ്ങളേക്കാൾ കുറവാണെങ്കിൽ, കൂട്ടിച്ചേർക്കലുകളൊന്നും സംഭവിക്കില്ല കൂടാതെ ഫംഗ്ഷൻ യഥാർത്ഥ ഇൻപുട്ട് അറേയെ തിരികെ നൽകും.
array_pad() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
$arr = അറേ(12, 10, 4);
$ഫലം = array_pad($arr, 5, 0);
// $ഫലം = അറേ(12, 10, 4, 0, 0);
$ഫലം = array_pad($arr, -7, -1);
// $ഫലം = അറേ(-1, -1, -1, -1, 12, 10, 4)
$ഫലം = array_pad($arr, 2, "noop");
// ചേർക്കില്ല
അറേ_മാപ്പ്
നിർദ്ദിഷ്ട ശ്രേണികളിലെ എല്ലാ ഘടകങ്ങളിലേക്കും ഒരു ഇഷ്ടാനുസൃത ഫംഗ്ഷൻ പ്രയോഗിക്കുക.
വാക്യഘടന:
Array array_map(മിക്സഡ് കോൾബാക്ക്, അറേ arr1 [, array ...])
array_map() ഫംഗ്ഷൻ ഉപയോക്താവിൻ്റെ കോൾബാക്ക് ഫംഗ്ഷൻ പ്രോസസ്സ് ചെയ്തതിന് ശേഷം എല്ലാ നിർദ്ദിഷ്ട അറേകളുടെയും ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു അറേ നൽകുന്നു.
ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്ഷനിലേക്ക് പാസാക്കിയ പാരാമീറ്ററുകളുടെ എണ്ണം, array_map()-ലേക്ക് കൈമാറിയ അറേകളുടെ എണ്ണവുമായി പൊരുത്തപ്പെടണം.
array_map() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം: ഒരൊറ്റ അറേ പ്രോസസ്സ് ചെയ്യുന്നു
തിരികെ $n*$n*$n;
}
$a = അറേ(1, 2, 3, 4, 5);
$b = array_map("ക്യൂബ്", $a);
print_r($b);
?>
അറേ(
=> 1
=> 8
=> 27
=> 64
=> 125
)
array_map() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം: ഒന്നിലധികം അറേകൾ പ്രോസസ്സ് ചെയ്യുന്നു
തിരികെ "സ്പാനിഷ് ഭാഷയിൽ $n എന്ന സംഖ്യ $m ആണ്";
}
ഫംഗ്ഷൻ മാപ്പ്_സ്പാനിഷ്($n, $m) (
റിട്ടേൺ അറേ ($n => $m);
}
$a = അറേ(1, 2, 3, 4, 5);
$b = അറേ("യൂണോ", "ഡോസ്", "ട്രെസ്", "ക്വാട്രോ", "സിൻകോ");
$c = array_map("show_Spanish", $a, $b);
print_r($c);
$d = array_map("map_Spanish", $a , $b);
print_r($d);
?>
നൽകിയിരിക്കുന്ന ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
// $cArray(യുടെ പ്രിൻ്റൗട്ട്
=> സ്പാനിഷിൽ നമ്പർ 1 - uno
=> സ്പാനിഷിൽ നമ്പർ 2 - ഡോസ്
=> സ്പാനിഷിൽ നമ്പർ 3 - ട്രെസ്
=> സ്പാനിഷിൽ നമ്പർ 4 - cuatro
=> സ്പാനിഷിൽ നമ്പർ 5 - cinco
)
// $dArray(യുടെ പ്രിൻ്റൗട്ട്
=> അറേ
=> uno
)
=> അറേ
=> ഡോസ്
)
=> അറേ
=> ട്രെസ്
)
=> അറേ
=> cuatro
)
=> അറേ
=> സിൻകോ
)
സാധാരണയായി ഒരേ വലുപ്പമുള്ള അറേകളിൽ array_map() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. അറേകൾക്ക് വ്യത്യസ്ത ദൈർഘ്യമുണ്ടെങ്കിൽ, ചെറിയവ ശൂന്യമായ മൂല്യങ്ങളുള്ള ഘടകങ്ങൾ ഉപയോഗിച്ച് പാഡ് ചെയ്യുന്നു.
പ്രോസസ്സിംഗ് ഫംഗ്ഷൻ്റെ പേരിനുപകരം നിങ്ങൾ null എന്ന് വ്യക്തമാക്കിയാൽ, അറേകളുടെ ഒരു ശ്രേണി സൃഷ്ടിക്കപ്പെടും എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.
array_map() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം: അറേകളുടെ ഒരു നിര സൃഷ്ടിക്കുന്നു
$b = അറേ ("ഒന്ന്", "രണ്ട്", "മൂന്ന്", "നാല്", "അഞ്ച്");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>
നൽകിയിരിക്കുന്ന ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> അറേ
=> 1
=>ഒന്ന്
=> uno
)
=> അറേ
=> 2
=> രണ്ട്
=> ഡോസ്
)
=> അറേ
=> 3
=> മൂന്ന്
=> ട്രെസ്
)
=> അറേ
=> 4
=> നാല്
=> cuatro
)
=> അറേ
=> 5
=> അഞ്ച്
=> സിൻകോ
)
PHP 4 >= 4.0.6, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_പോപ്പ്
ഒരു അറേയുടെ അവസാന ഘടകങ്ങൾ വീണ്ടെടുക്കുകയും നീക്കം ചെയ്യുകയും ചെയ്യുന്നു.
വാക്യഘടന:
മിക്സഡ് അറേ_പോപ്പ് (അറേ അറേ);
array_pop() ഫംഗ്ഷൻ അറേ arr-ൽ നിന്നുള്ള അവസാന ഘടകത്തെ പോപ്പ് ചെയ്യുകയും അത് തിരികെ നൽകുകയും പിന്നീട് അത് നീക്കം ചെയ്യുകയും ചെയ്യുന്നു. ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച് നമുക്ക് സ്റ്റാക്ക് പോലുള്ള ഘടനകൾ നിർമ്മിക്കാൻ കഴിയും. അറേ അറേ ശൂന്യമായിരുന്നെങ്കിലോ അതൊരു അറേ അല്ലെങ്കിലോ, ഫംഗ്ഷൻ ശൂന്യമായ സ്ട്രിംഗ് NULL നൽകുന്നു.
array_pop() ഫംഗ്ഷൻ ഉപയോഗിച്ചതിന് ശേഷം, അറേ കഴ്സർ ആരംഭത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു.
array_pop() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
$fruits = array_pop($stack);
print_r ($ സ്റ്റാക്ക്);
print_r ($ പഴങ്ങൾ);
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> ഓറഞ്ച്
=> വാഴപ്പഴം
=> ആപ്പിൾ
)
PHP 4, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_പുഷ്
അറേയുടെ അവസാനം ഒന്നോ അതിലധികമോ ഘടകങ്ങൾ ചേർക്കുന്നു.
വാക്യഘടന:
Int array_push(array arr, mixed var1 [, mixed var2, ..])
array_push() ഫംഗ്ഷൻ, var1, var2 മുതലായവയെ അറേ arr-ലേക്ക് ചേർക്കുന്നു. ഇത് അവർക്ക് സംഖ്യാ സൂചികകൾ നൽകുന്നു - അത് സ്റ്റാൻഡേർഡിന് ചെയ്യുന്നതുപോലെ തന്നെ.
നിങ്ങൾക്ക് ഒരു ഘടകം മാത്രം ചേർക്കണമെങ്കിൽ, ഈ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നത് എളുപ്പമായേക്കാം:
Array_push($Arr,1000); // ഫംഗ്ഷനെ വിളിക്കുക$Arr=100; // അതേ കാര്യം, പക്ഷേ ചെറുതാണ്
array_push() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
array_push($stack, "apple", "raspberry");
print_r ($ സ്റ്റാക്ക്);
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> ഓറഞ്ച്
=> വാഴപ്പഴം
=> ആപ്പിൾ
=> റാസ്ബെറി
)
array_push() ഫംഗ്ഷൻ അറേയെ ഒരു സ്റ്റാക്ക് ആയി കണക്കാക്കുകയും എല്ലായ്പ്പോഴും ഘടകങ്ങൾ അവസാനം വരെ ചേർക്കുകയും ചെയ്യുന്നു എന്നത് ശ്രദ്ധിക്കുക.
PHP 4, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_ഷിഫ്റ്റ്
ഒരു അറേയുടെ ആദ്യ ഘടകം വീണ്ടെടുക്കുകയും നീക്കം ചെയ്യുകയും ചെയ്യുന്നു.
വാക്യഘടന:
മിക്സഡ് അറേ_ഷിഫ്റ്റ്(അറേ അറേ)
array_shift() ഫംഗ്ഷൻ അറേ arr-ൻ്റെ ആദ്യ ഘടകം എടുത്ത് അത് തിരികെ നൽകുന്നു. ഇത് array_pop(),
എന്നാൽ ഇത് പ്രാരംഭം മാത്രമേ സ്വീകരിക്കുകയുള്ളൂ, അന്തിമ ഘടകമല്ല, കൂടാതെ മുഴുവൻ ശ്രേണിയുടെയും ശക്തമായ “ഷേക്ക്-അപ്പ്” ഉൽപ്പാദിപ്പിക്കുകയും ചെയ്യുന്നു: എല്ലാത്തിനുമുപരി, ആദ്യ ഘടകം വേർതിരിച്ചെടുക്കുമ്പോൾ, ശേഷിക്കുന്ന എല്ലാ ഘടകങ്ങളുടെയും എല്ലാ സംഖ്യാ സൂചികകളും നിങ്ങൾ ക്രമീകരിക്കേണ്ടതുണ്ട്, കാരണം അറേയുടെ തുടർന്നുള്ള എല്ലാ ഘടകങ്ങളും ഒരു സ്ഥാനം മുന്നോട്ട് മാറ്റുന്നു. സ്ട്രിംഗ് അറേ കീകൾ മാറില്ല.
arr ശൂന്യമോ അറേ അല്ലെങ്കിലോ, ഫംഗ്ഷൻ NULL നൽകുന്നു.
ഈ ഫംഗ്ഷൻ ഉപയോഗിച്ച ശേഷം, അറേ പോയിൻ്റർ തുടക്കത്തിലേക്ക് നീക്കുന്നു.
array_shift() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
$fruit = array_shift($stack);
print_r ($ സ്റ്റാക്ക്);
?>
ഈ ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> വാഴപ്പഴം
=> ആപ്പിൾ
=> റാസ്ബെറി
)
$fruit വേരിയബിളിന് "ഓറഞ്ച്" എന്ന മൂല്യം ഉണ്ടായിരിക്കും
PHP 4, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_അൺഷിഫ്റ്റ്
അറേയുടെ തുടക്കത്തിലേക്ക് ഒന്നോ അതിലധികമോ മൂല്യങ്ങൾ ചേർക്കുന്നു.
വാക്യഘടന:
Int array_unshift(list arr, mixed var1 [,mixed var2, ...])
array_unshift() ഫംഗ്ഷൻ പാസാക്കിയ var മൂല്യങ്ങളെ arr അറേയുടെ തുടക്കത്തിലേക്ക് ചേർക്കുന്നു. അറേയിലെ പുതിയ മൂലകങ്ങളുടെ ക്രമം സംരക്ഷിക്കപ്പെട്ടിരിക്കുന്നു. അറേയുടെ എല്ലാ ഡിജിറ്റൽ സൂചികകളും മാറ്റപ്പെടും, അങ്ങനെ അത് പൂജ്യത്തിൽ നിന്ന് ആരംഭിക്കും. അറേയുടെ എല്ലാ സ്ട്രിംഗ് സൂചികകളും മാറ്റമില്ല.
ഫംഗ്ഷൻ അറേയിലെ മൂലകങ്ങളുടെ പുതിയ എണ്ണം നൽകുന്നു.
array_unshift() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:
array_unshift($ക്യൂ, "ആപ്പിൾ", "റാസ്ബെറി");
?>
ഇപ്പോൾ $ക്യൂ വേരിയബിളിന് ഇനിപ്പറയുന്ന ഘടകങ്ങൾ ഉണ്ടായിരിക്കും:
അറേ(
=> ആപ്പിൾ
=> റാസ്ബെറി
=> ഓറഞ്ച്
=> വാഴപ്പഴം
)
PHP 4, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_തനത്
ഒരു അറേയിലെ തനിപ്പകർപ്പ് മൂല്യങ്ങൾ നീക്കംചെയ്യുന്നു.
വാക്യഘടന:
അറേ array_unique(array arr)
array_unique() ഫംഗ്ഷൻ, എല്ലാ തനിപ്പകർപ്പ് മൂല്യങ്ങളും നീക്കം ചെയ്തുകൊണ്ട്, അറേ അറേയിലെ എല്ലാ അദ്വിതീയ മൂല്യങ്ങളും അവയുടെ കീകൾക്കൊപ്പം ഒരു അറേ നൽകുന്നു. നേരിട്ട ആദ്യത്തെ കീ=>മൂല്യ ജോഡികൾ ഫലമായുണ്ടാകുന്ന അറേയിൽ സ്ഥാപിച്ചിരിക്കുന്നു. സൂചികകൾ സംരക്ഷിച്ചിരിക്കുന്നു.
array_unique() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:
"പച്ച", "ചുവപ്പ്", "ബി" =>
"പച്ച", "നീല", "ചുവപ്പ്");
print_r ($ ഫലം);
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
[a] => പച്ച
=>ചുവപ്പ്
=> നീല
)
array_unique() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം: ഡാറ്റ തരങ്ങൾ താരതമ്യം ചെയ്യുന്നു
$ഫലം = array_unique($input);
var_dump ($ ഫലം);
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(2) (
=> int(4)
=> സ്ട്രിംഗ്(1) "3"
}
PHP 4 >= 4.0.1, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം
അറേ_ചങ്ക്
ഫംഗ്ഷൻ അറേയെ ഭാഗങ്ങളായി വിഭജിക്കുന്നു.
വാക്യഘടന:
അറേ അറേ_ചങ്ക് (അറേ ആർ, ഇൻ്റ് സൈസ് [, ബൂൾ പ്രിസർവ്_കീകൾ])
array_chunk() ഫംഗ്ഷൻ യഥാർത്ഥ അറേ arr-നെ നിരവധി അറേകളായി വിഭജിക്കുന്നു, അതിൻ്റെ ദൈർഘ്യം സംഖ്യയുടെ വലുപ്പം അനുസരിച്ച് വ്യക്തമാക്കുന്നു. ഒറിജിനൽ അറേയുടെ അളവ് ഭാഗങ്ങളുടെ വലുപ്പം കൊണ്ട് കൃത്യമായി ഹരിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, അന്തിമ അറേയ്ക്ക് ഒരു ചെറിയ മാനം ഉണ്ടായിരിക്കും.
array_chunk() ഫംഗ്ഷൻ ഒരു മൾട്ടിഡൈമൻഷണൽ അറേ നൽകുന്നു, ഇതിൻ്റെ സൂചികകൾ 0 മുതൽ ഫലമായുണ്ടാകുന്ന അറേകളുടെ എണ്ണം വരെ ആരംഭിക്കുന്നു, കൂടാതെ മൂല്യങ്ങൾ വിഭജനത്തിൻ്റെ ഫലമായി ലഭിച്ച അറേകളാണ്.
ഒറിജിനൽ അറേയുടെ കീകൾ സംരക്ഷിക്കണമോ വേണ്ടയോ എന്ന് ഓപ്ഷണൽ preserv_keys പാരാമീറ്റർ വ്യക്തമാക്കുന്നു. ഈ പരാമീറ്റർ തെറ്റാണെങ്കിൽ (സ്ഥിര മൂല്യം), തത്ഫലമായുണ്ടാകുന്ന അറേകളുടെ സൂചികകൾ പൂജ്യത്തിൽ നിന്ന് ആരംഭിക്കുന്ന സംഖ്യകളാൽ വ്യക്തമാക്കും. പരാമീറ്റർ ശരിയാണെങ്കിൽ, യഥാർത്ഥ അറേയുടെ കീകൾ സംരക്ഷിക്കപ്പെടും.
array_chunk() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
$അറേ = അറേ("ഒന്നാം ഘടകം",
"രണ്ടാം ഘടകം"
"മൂന്നാം ഘടകം"
"നാലാം ഘടകം"
"അഞ്ചാമത്തെ ഘടകം");
print_r(array_chunk($array, 2));
print_r(array_chunk($array, 2, TRUE));
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> അറേ
=> ആദ്യ ഘടകം
=> രണ്ടാമത്തെ ഘടകം
)
=> അറേ
=> മൂന്നാം ഘടകം
=> നാലാമത്തെ ഘടകം
)
=> അറേ
=> അഞ്ചാമത്തെ ഘടകം
)
)
അറേ(
=> അറേ
=> ആദ്യ ഘടകം
=> രണ്ടാമത്തെ ഘടകം
)
=> അറേ
=> മൂന്നാം ഘടകം
=> നാലാമത്തെ ഘടകം
)
=> അറേ
=> അഞ്ചാമത്തെ ഘടകം
)
PHP 4 >= 4.2.0, PHP 5 പിന്തുണയ്ക്കുന്ന ഫംഗ്ഷൻ
അറേ_ഫിൽ
ഫംഗ്ഷൻ നിർദ്ദിഷ്ട മൂല്യങ്ങൾ ഉപയോഗിച്ച് അറേ പൂരിപ്പിക്കുന്നു.
വാക്യഘടന:
Array array_fill(int start_index, int num, mixed value)
array_fill() ഫംഗ്ഷൻ, start_index പാരാമീറ്ററിൽ വ്യക്തമാക്കിയ ഘടകത്തിൽ നിന്ന് ആരംഭിക്കുന്ന, വലുപ്പ സംഖ്യയുടെ മൂല്യ പാരാമീറ്ററിൽ വ്യക്തമാക്കിയ മൂല്യങ്ങൾ അടങ്ങുന്ന ഒരു അറേ നൽകുന്നു.
array_diff_uassoc() ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
print_r($a);
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
അറേ(
=> വാഴപ്പഴം
=> വാഴപ്പഴം
=> വാഴപ്പഴം
=> വാഴപ്പഴം
=> വാഴപ്പഴം
=> വാഴപ്പഴം
)
PHP 4 >= 4.2.0, PHP 5 പിന്തുണയ്ക്കുന്ന ഫംഗ്ഷൻ
അറേ_ഫിൽറ്റർ
ഒരു ഇഷ്ടാനുസൃത ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു അറേയ്ക്ക് ഫംഗ്ഷൻ ഒരു ഫിൽട്ടർ പ്രയോഗിക്കുന്നു.
വാക്യഘടന:
അറേ അറേ_ഫിൽറ്റർ(അറേ ഇൻപുട്ട് [, കോൾബാക്ക് കോൾബാക്ക്])
ഉപയോക്താവ് നിർവചിച്ച കോൾബാക്ക് ഫംഗ്ഷൻ്റെ ഫലങ്ങൾ അനുസരിച്ച് ഫിൽട്ടർ ചെയ്ത ഇൻപുട്ട് അറേയിൽ കാണപ്പെടുന്ന മൂല്യങ്ങൾ അടങ്ങുന്ന ഒരു അറേ array_filter() ഫംഗ്ഷൻ നൽകുന്നു.
ഇൻപുട്ട് അറേ ഒരു അസോസിയേറ്റീവ് അറേ ആണെങ്കിൽ, ഫലമായുണ്ടാകുന്ന അറേയിൽ സൂചികകൾ സംരക്ഷിക്കപ്പെടും.
array_filter() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനുള്ള ഉദാഹരണം:
റിട്ടേൺ ($var % 2 == 1);
}
ഫംഗ്ഷൻ ഈവൻ($var) (
റിട്ടേൺ ($var % 2 == 0);
}
$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = അറേ(6, 7, 8, 9, 10, 11, 12);
പ്രതിധ്വനി "ഓഡ്: എൻ";
print_r(array_filter($array1, "odd"));
പ്രതിധ്വനി "Even:n";
t_r(array_filter($array2, "പോലും"));
?>
ഉദാഹരണം ഇനിപ്പറയുന്നവ ഔട്ട്പുട്ട് ചെയ്യും:
വിചിത്രം:അറേ(
[a] => 1
[c] => 3
[ഇ] => 5
പോലും:അറേ(
=> 6
=> 8
=> 10
=> 12
)
ഫിൽട്ടറിംഗ് ഫംഗ്ഷൻ്റെ പേരിനുപകരം, ഒബ്ജക്റ്റിലേക്കും രീതിയുടെ പേരിലേക്കും ഒരു റഫറൻസ് അടങ്ങിയിരിക്കുന്ന ഒരു അറേ നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.
array_filter() ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു അറേ പ്രോസസ്സ് ചെയ്യുമ്പോൾ, അത് മാറ്റാൻ കഴിയില്ല എന്നതും ശ്രദ്ധിക്കേണ്ടതാണ്: ഘടകങ്ങൾ ചേർക്കുക, നീക്കംചെയ്യുക അല്ലെങ്കിൽ അറേ പുനഃസജ്ജമാക്കുക, കാരണം ഇത് പ്രവർത്തനത്തിൻ്റെ തെറ്റായ പ്രവർത്തനത്തിലേക്ക് നയിച്ചേക്കാം.
PHP 4 >= 4.0.6, PHP 5 പിന്തുണയ്ക്കുന്ന പ്രവർത്തനം