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

മൂന്ന് വ്യത്യസ്ത തരം അറേകൾ ഉണ്ട്, ഓരോ അറേ മൂല്യവും അറേ ഇൻഡക്സ് എന്ന് വിളിക്കുന്ന ഒരു ഐഡൻ്റിഫയർ സി ആക്സസ് ചെയ്യുന്നു.

• സംഖ്യാ ശ്രേണി- ഒരു സംഖ്യാ സൂചികയുള്ള ഒരു അറേ. മൂല്യങ്ങൾ ഒരു രേഖീയ രീതിയിൽ സംഭരിക്കുകയും ആക്സസ് ചെയ്യുകയും ചെയ്യുന്നു.
• അസോസിയേറ്റീവ് അറേ- ഒരു സൂചികയായി സ്ട്രിംഗുകളുള്ള ഒരു ശ്രേണി. ഇത് കർശനമായ രേഖീയ സൂചിക ക്രമത്തിന് പകരം പ്രധാന മൂല്യങ്ങളുമായി സംയോജിപ്പിച്ച് മൂലക മൂല്യങ്ങൾ സംഭരിക്കുന്നു.
• മൾട്ടിഡൈമൻഷണൽ അറേ. ഒന്നോ അതിലധികമോ അറേകളും മൂല്യങ്ങളും അടങ്ങുന്ന ഒരു അറേ ഒന്നിലധികം സൂചികകൾ ഉപയോഗിച്ച് ആക്സസ് ചെയ്യുന്നു

സംഖ്യാ ശ്രേണി

ഈ അറേകൾക്ക് നമ്പറുകളും സ്ട്രിംഗുകളും ഏത് വസ്തുവും സംഭരിക്കാൻ കഴിയും, എന്നാൽ അവയുടെ സൂചികയെ അക്കങ്ങളാൽ പ്രതിനിധീകരിക്കും. സ്ഥിരസ്ഥിതിയായി, അറേ സൂചിക പൂജ്യത്തിൽ ആരംഭിക്കുന്നു.

ഉദാഹരണം

സംഖ്യാ ശ്രേണികൾ സൃഷ്ടിക്കുന്നതിനും ആക്സസ് ചെയ്യുന്നതിനുമുള്ള ഒരു ഉദാഹരണം ചുവടെയുണ്ട്.

ഇവിടെ നമ്മൾ ഒരു അറേ ഉണ്ടാക്കാൻ അറേ() ഫംഗ്ഷൻ ഉപയോഗിച്ചു. ഈ സവിശേഷത സവിശേഷത വിവരണത്തിൽ വിശദീകരിച്ചിരിക്കുന്നു.

മൂല്യം 1 ആണ്
മൂല്യം 2 ആണ്
മൂല്യം 3 ആണ്
മൂല്യം 4 ആണ്
മൂല്യം 5 ആണ്
മൂല്യം ഒന്നാണ്
മൂല്യം രണ്ടാണ്
മൂല്യം മൂന്നാണ്
മൂല്യം നാലാണ്
മൂല്യം അഞ്ച്

അസോസിയേറ്റീവ് അറേകൾ

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

ജീവനക്കാരുടെ ശമ്പളം ഒരു അറേയിൽ സംഭരിക്കുന്നതിന്, ഒരു സംഖ്യാ സൂചിക അറേ മികച്ച ചോയ്‌സ് ആയിരിക്കില്ല. പകരം, ഞങ്ങളുടെ അസോസിയേറ്റീവ് അറേയിലെ കീകളായി ജീവനക്കാരുടെ പേരുകൾ ഉപയോഗിക്കാം, മൂല്യം അവരുടെ അനുബന്ധ ശമ്പളമായിരിക്കും.

കുറിപ്പ്. പ്രിൻ്റ് ചെയ്യുമ്പോൾ ഇരട്ട ഉദ്ധരണിക്കുള്ളിൽ അസോസിയേറ്റീവ് അറേ സൂക്ഷിക്കരുത്, അല്ലാത്തപക്ഷം അത് ഒരു മൂല്യവും നൽകില്ല.

ഉദാഹരണം

2000, "ഖാദിർ" => 1000, "സറ" => 500); പ്രതിധ്വനി "മുഹമ്മദിൻ്റെ ശമ്പളം". $ശമ്പളം["മുഹമ്മദ്"] . ""; പ്രതിധ്വനി "ഖാദറിൻ്റെ ശമ്പളം". $ശമ്പളങ്ങൾ["ഖാദിർ"]. ""; പ്രതിധ്വനി "സാറയുടെ ശമ്പളം". $ശമ്പളങ്ങൾ["zara"]. ""; /* അറേ സൃഷ്ടിക്കുന്നതിനുള്ള രണ്ടാമത്തെ രീതി. */ $ ശമ്പളം["മുഹമ്മദ്"] = "ഉയർന്നത്"; $ശമ്പളങ്ങൾ["ഖാദിർ"] = "ഇടത്തരം"; $ശമ്പളങ്ങൾ["zara"] = "കുറഞ്ഞത്"; പ്രതിധ്വനി "മുഹമ്മദിൻ്റെ ശമ്പളം". $ശമ്പളം["മുഹമ്മദ്"] . ""; പ്രതിധ്വനി "ഖാദറിൻ്റെ ശമ്പളം". $ശമ്പളങ്ങൾ["ഖാദിർ"]. ""; പ്രതിധ്വനി "സാറയുടെ ശമ്പളം". $ശമ്പളങ്ങൾ["zara"]. ""; ?>

ഇത് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കും -

മുഹമ്മദിൻ്റെ ശമ്പളം 2000
1000 രൂപയാണ് ഖാദറിൻ്റെ ശമ്പളം
സറയുടെ ശമ്പളം 500
മുഹമ്മദിന് ഉയർന്ന ശമ്പളം
ഖാദറിൻ്റെ ശമ്പളം ഇടത്തരം
സാറയുടെ ശമ്പളം കുറവാണ്

മൾട്ടിഡൈമൻഷണൽ അറേകൾ

മൾട്ടിഡൈമൻഷണൽ അറേ പ്രധാന അറേയിലെ ഓരോ ഘടകവും ഒരു അറേ ആകാം. ഉപ-അറേയിലെ ഓരോ ഘടകവും ഒരു അറേയും മറ്റും ആകാം. മൾട്ടിഡൈമൻഷണൽ അറേയിലെ മൂല്യങ്ങൾ ഒന്നിലധികം സൂചികകൾ ഉപയോഗിച്ച് ആക്സസ് ചെയ്യപ്പെടുന്നു.

ഉദാഹരണം

ഈ ഉദാഹരണത്തിൽ, മൂന്ന് വിഷയങ്ങളിലെ മൂന്ന് വിദ്യാർത്ഥികളുടെ മാർക്ക് സംഭരിക്കുന്നതിന് ഞങ്ങൾ ഒരു ദ്വിമാന അറേ സൃഷ്ടിക്കുന്നു. ഈ ഉദാഹരണം ഒരു അസോസിയേറ്റീവ് അറേയാണ്, നിങ്ങൾക്ക് അതേ രീതിയിൽ ഒരു സംഖ്യാ അറേ സൃഷ്ടിക്കാൻ കഴിയും.

അറേ ("ഫിസിക്സ്" => 35, "ഗണിതശാസ്ത്രം" => 30, "രസതന്ത്രം" => 39), "ഖാദിർ" => അറേ ("ഫിസിക്സ്" => 30, "ഗണിതം" => 32, "രസതന്ത്രം" => 29), "zara" => അറേ ("ഫിസിക്സ്" => 31, "ഗണിതശാസ്ത്രം" => 22, "രസതന്ത്രം" => 39)); /* മൾട്ടി-ഡൈമൻഷണൽ അറേ മൂല്യങ്ങൾ ആക്സസ് ചെയ്യുന്നു */ പ്രതിധ്വനി "ഭൗതികശാസ്ത്രത്തിൽ മൊഹമ്മദിനുള്ള മാർക്ക്:" ; echo $marks["mohammad"]["physics"] . ""; പ്രതിധ്വനി "ഗണിതത്തിലെ ഖാദിറിൻ്റെ മാർക്ക്: "; പ്രതിധ്വനി $marks["qadir"]["maths"] . ""; പ്രതിധ്വനി "രസതന്ത്രത്തിൽ സരയ്ക്കുള്ള മാർക്ക്:" ; echo $marks["zara"]["chemistry"] . ""; ?>

ഇത് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കും -

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

PHP-യിൽ ഒരു ലളിതമായ അറേ എങ്ങനെ സൃഷ്ടിക്കാം

ഒരു ലളിതമായ അറേ ഇതുപോലെ കാണപ്പെടുന്നു:

ഡാറ്റയിലേക്ക് നിങ്ങളുടെ ശ്രദ്ധ ഉടനടി ആകർഷിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു (അതെ, ഞാൻ അത് ഉദ്ദേശ്യത്തോടെയാണ് എഴുതിയത് :)). ഡാറ്റ തരം സ്ട്രിംഗ്, അല്ലെങ്കിൽ സ്ട്രിംഗ്എല്ലായ്‌പ്പോഴും ഉദ്ധരണി ചിഹ്നങ്ങളിൽ എഴുതുക, അവ ഏതാണ് എന്നത് പ്രശ്നമല്ല, ഒറ്റയും ഇരട്ടയും പ്രവർത്തിക്കും (പ്രധാന കാര്യം, വരി ഒരേ ഉദ്ധരണി ചിഹ്നത്തിൽ ആരംഭിക്കുകയും അവസാനിക്കുകയും ചെയ്യുന്നു എന്നതാണ്). 29 എന്ന സംഖ്യയ്ക്ക് ഒരു തരം ഉണ്ട് പൂർണ്ണസംഖ്യ, അല്ലെങ്കിൽ ഈ ഡാറ്റ തരങ്ങൾക്ക് നമ്പർ ഉദ്ധരണികൾ ആവശ്യമില്ല.
$my_array അറേ എങ്ങനെയുണ്ടെന്ന് പരിശോധിക്കാം:

"; print_r($my_array); echo ""; /* അറേ നേടുക ( => ചെയർ => ക്ലൗഡ് => 29) */ ?>

ഒരു ലളിതമായ അറേ ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്.
0,1,2 - ഞങ്ങളുടെ ശ്രേണിയുടെ സൂചികകൾ. സൂചികകളുടെ സഹായത്തോടെ നമുക്ക് ഒരു അറേയിൽ നിന്ന് എന്തെങ്കിലും പ്രത്യേകമായി അനുമാനിക്കാം.

കൂടാതെ, നമ്മൾ എഴുതുകയാണെങ്കിൽ അതേ അറേ സൃഷ്ടിക്കാൻ കഴിയും:

കൂടാതെ, മൂന്നാമത്തെ വഴിയുണ്ട്:

"ചെയർ", 1 => "ക്ലൗഡ്", 2 => 29);?>

ഒപ്പം നാലാമത്തേതും :)

സൂചികകൾ 0 മുതൽ പൂരിപ്പിക്കും.

PHP എന്താണ് ഒരു അസോസിയേറ്റീവ് അറേ

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

കസേര => ക്ലൗഡ് => 29) */ ?>

വിളിക്കാൻ ഞങ്ങൾ ഉപയോഗിക്കും

നമ്പറിന് പകരം ( സൂചിക) ഞങ്ങൾ അർത്ഥവത്തായ ഒരു പേര് (അസോസിയേഷൻ) സജ്ജമാക്കി, ഞങ്ങളുടെ സൂചികയെ ഇപ്പോൾ വിളിക്കാം അറേ കീ(ഇനം, ആകാശം, നമ്പർ). ഒരു അസോസിയേറ്റീവ് അറേയ്ക്കുള്ള ഏറ്റവും ജനപ്രിയവും, ഒരുപക്ഷേ, ഏറ്റവും സൗകര്യപ്രദവുമായ നൊട്ടേഷൻ:

"ചെയർ", "ആകാശം" => "ക്ലൗഡ്", "നമ്പർ" => 29); ?>

മൾട്ടിഡൈമൻഷണൽ അറേ

ഈ ഭീമനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ :)

അറേ ("നിറം" => "ചുവപ്പ്", "വർഷം" => "2010", "മാർക്ക്" => "M5"), "ഓഡി" => അറേ ("നിറം" => "കറുപ്പ്", "വർഷം" = > "2011", "മാർക്ക്" => "TT")); പ്രിൻ്റ്_ആർ ($ ഓട്ടോ); // അറേ ഔട്ട്‌പുട്ട് എക്കോ $auto["bmw"]["mark"]; // M5 ?>

നിങ്ങൾ മനസ്സിലാക്കുന്നതുപോലെ, ഒരു സ്ട്രിംഗോ സംഖ്യയോ ആയിരുന്ന ഒരു മൂല്യത്തിന് പകരം, ഇപ്പോൾ ഒരു അറേ പോലുള്ള ഒരു ഡാറ്റ തരം ഉണ്ട് ( ഞാൻ നിങ്ങളെ ഒരു അറേയ്‌ക്കുള്ളിൽ ഒരു അറേ ആക്കും, അങ്ങനെ നിങ്ങൾ അറേയെ വിളിക്കുമ്പോൾ മറ്റൊരു അറേ ഉണ്ടാകും :)).

PHP-യിലെ ഒരു അറേ എന്താണെന്ന് നമുക്ക് കണ്ടുപിടിക്കാം. ഒരു അറേ എന്നത് മൊത്തത്തിൽ അവതരിപ്പിക്കുന്ന മൂല്യങ്ങളുടെ ഒരു കൂട്ടമാണ്. ഒരു പഴക്കൊട്ട സങ്കൽപ്പിക്കുക. അതിൽ ഒരു വാഴപ്പഴം, ഓറഞ്ച്, ആപ്പിൾ, മുന്തിരി എന്നിവ അടങ്ങിയിരിക്കുന്നു. PHP-യിൽ, നിങ്ങൾക്ക് അത്തരമൊരു ഘടനയെ ഒരു അറേ ആയി പ്രതിനിധീകരിക്കാൻ കഴിയും. കൊട്ട എന്നത് അറേ തന്നെയാണ്, പ്രത്യേക പഴങ്ങൾ അതിൻ്റെ ഘടകങ്ങളാണ്.

അറേകളുമായുള്ള നമ്മുടെ പരീക്ഷണങ്ങൾക്കായി നമുക്ക് ഇപ്പോൾ നമ്മുടെ പ്രോജക്‌റ്റിനൊപ്പം ഫോൾഡറിൽ ഒരു ഫയൽ സൃഷ്‌ടിക്കാം. നമുക്ക് അവനെ വിളിക്കാം arrays.php.

സ്ക്വയർ ബ്രാക്കറ്റുകൾ ഉപയോഗിച്ച് പിഎച്ച്‌പിയിൽ ഒരു അറേ ഡിക്ലയർ ചെയ്യപ്പെടുന്നു, ഇതുപോലെ:

ഇങ്ങനെയാണ് ഞങ്ങൾ ഒരു ശൂന്യമായ അറേ സൃഷ്ടിച്ചത്.

പഴയ കോഡിൽഅത്തരമൊരു അറേ നിർവചനത്തിൻ്റെ ഒരു ഉദാഹരണം നിങ്ങൾക്ക് കണ്ടെത്താം:

$ പഴങ്ങൾ = അറേ ();

ഈ എൻട്രി ഇപ്പോൾ കാലഹരണപ്പെട്ടതാണ്, ഉപയോഗിക്കാൻ പാടില്ല!

നിങ്ങൾക്ക് ഇതിനകം ചില മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു അറേ സൃഷ്ടിക്കാനും കഴിയും. ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:

$fruits = ["ആപ്പിൾ", "ഓറഞ്ച്", "മുന്തിരി"];

ഞങ്ങൾക്ക് ഇതിനകം അറിയാവുന്ന var_dump ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഫലമായുണ്ടാകുന്ന അറേ നിങ്ങൾക്ക് പ്രദർശിപ്പിക്കാൻ കഴിയും:

ബ്രൗസറിൽ തുറന്ന് നമ്മുടേതായ ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാം: http://myproject.loc/arrays.php
ഇനിപ്പറയുന്നവ ഞങ്ങൾ കാണും:

C:\OpenServer\domains\myproject.loc\www\arrays.php:4: അറേ (വലിപ്പം=3) 0 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 1 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 2 => "മുന്തിരി" (നീളം=5)

അക്കമിട്ട അറേകൾ

അറേ എന്നത് ഒരു ഒബ്‌ജക്റ്റ് തരമാണ്, അതായത് ഒരു അറേ. വലുപ്പം=3 എന്നത് അറേയുടെ വലുപ്പമാണ് (3 ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു). 0, 1, 2 ആണ് അറേ കീകൾ, എന്നും വിളിക്കപ്പെടുന്നു സൂചികകൾ. ഈ കീകൾ മൂല്യങ്ങൾ സംഭരിക്കുന്നു, ഞങ്ങളുടെ കാര്യത്തിൽ ഈ മൂല്യങ്ങൾ സ്ട്രിംഗുകളാണ്. നമുക്ക് കാണാനാകുന്നതുപോലെ, അറേ കീകൾ പൂജ്യത്തിൽ നിന്ന് അക്കമിട്ടിരിക്കുന്നു, തുടർന്ന് ഒന്ന് വർദ്ധിപ്പിച്ചിരിക്കുന്നു.

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

ഉദാഹരണത്തിന്, ഒരു അറേയുടെ പൂജ്യം ഘടകം ലഭിക്കുന്നതിന് (കീ 0 ഉപയോഗിച്ച്), ഞങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യും:

ഈ കോഡിൻ്റെ ഫലം:

സൂചിക 2-ലെ ഘടകം നമുക്ക് കണ്ടെത്താം:

ഫലമായി:

നിലവിലില്ലാത്ത സൂചികയുള്ള ഒരു ഘടകം ലഭിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, ഉദാഹരണത്തിന് - 3:

അത്തരമൊരു കീ ഉള്ള ഒരു ഘടകം കണ്ടെത്തിയില്ല എന്ന മുന്നറിയിപ്പ് ഞങ്ങൾക്ക് ലഭിക്കും.

അറേ ഘടകങ്ങൾ ചേർക്കുകയും നീക്കം ചെയ്യുകയും ചെയ്യുന്നു

ഇനിപ്പറയുന്ന നിർമ്മാണം ഉപയോഗിച്ച് നമുക്ക് മറ്റൊരു ഘടകം അറേയിലേക്ക് ചേർക്കാം:

$പഴങ്ങൾ = "മാങ്ങ";

var_dump ഉപയോഗിച്ച് നമുക്ക് നമ്മുടെ അറേ വീണ്ടും നോക്കാം:

ഫലം സൂചിക 3 ഉള്ള മറ്റൊരു ഘടകമാണ്:

C:\OpenServer\domains\myproject.loc\www\arrays.php:7: അറേ (വലിപ്പം=4) 0 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 1 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 2 => ചരട് "മുന്തിരി" (നീളം=5) 3 => "മാമ്പഴം" (നീളം=5)

അറേ ഘടകങ്ങൾ നീക്കംചെയ്യാൻ, സജ്ജമാക്കാത്ത നിർമ്മാണം ഉപയോഗിക്കുക. സൂചിക 2-ലെ ഘടകം നീക്കം ചെയ്യാം:

ഈ കോഡിൻ്റെ ഫലം:

C:\OpenServer\domains\myproject.loc\www\arrays.php:9: അറേ (വലിപ്പം=3) 0 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 1 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 3 => "മാമ്പഴം" (നീളം=5)

നമുക്ക് കാണാനാകുന്നതുപോലെ, സൂചിക 2 ഉള്ള മൂലകം നിലവിലില്ല, കീകളുടെ സീരിയൽ നമ്പറുകളിൽ ഒരു "ദ്വാരം" പ്രത്യക്ഷപ്പെട്ടു. നമ്മൾ ഇപ്പോൾ ഒരു പുതിയ ഘടകം ചേർക്കുകയാണെങ്കിൽ, അതിൻ്റെ സൂചിക 4 ആയിരിക്കും, എന്നാൽ ഈ ദ്വാരം ഇപ്പോഴും നിലനിൽക്കും. ഇത് കൃത്യമായി പ്രവർത്തിക്കുന്നത് ഇതാണ്, നിങ്ങൾ ഓർമ്മിക്കേണ്ടത് ഇതാണ്.

വീണ്ടും കീകളിലേക്ക് മടങ്ങുക

പൊതുവായി പറഞ്ഞാൽ, അറേ സൃഷ്ടിക്കുമ്പോൾ പോലും നിങ്ങൾക്ക് ഈ കീകൾ സ്വയം സജ്ജമാക്കാൻ കഴിയും. ഇതുപോലെ:

ഫലമായി:

C:\OpenServer\domains\myproject.loc\www\arrays.php:5: അറേ (വലിപ്പം=3) 5 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 3 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 9 => "മുന്തിരി" (നീളം=5)

നമുക്ക് കാണാനാകുന്നതുപോലെ, കീകൾ ഇപ്പോൾ 5, 3, 9 എന്നിവയാണ്.
നമ്മൾ ഇപ്പോൾ അറേയിലേക്ക് ഒരു ഘടകം ചേർക്കുകയാണെങ്കിൽ, കീയുടെ പരമാവധി സംഖ്യാ മൂല്യത്തേക്കാൾ വലിയ ഒരു സൂചിക അതിന് ഉണ്ടായിരിക്കും:

ഫലമായി:

C:\OpenServer\domains\myproject.loc\www\arrays.php:7: അറേ (വലിപ്പം=4) 5 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 3 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 9 => ചരട് "മുന്തിരി" (നീളം=5) 10 => "മാമ്പഴം" (നീളം=5)

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

ഫലമായി:

C:\OpenServer\domains\myproject.loc\www\arrays.php:7: അറേ (വലിപ്പം=4) 5 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 3 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 9 => ചരട് "മുന്തിരി" (നീളം=5) 20 => "മാമ്പഴം" (നീളം=5)

അത്തരമൊരു കീയുടെ മൂല്യം ഇതിനകം അറേയിലുണ്ടെങ്കിൽ, അത് പുതിയൊരെണ്ണം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും. ഉദാഹരണത്തിന്, നമുക്ക് ആപ്പിളിനെ മാങ്ങ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം:

ഫലമായി:

C:\OpenServer\domains\myproject.loc\www\arrays.php:5: അറേ (വലിപ്പം=3) 5 => സ്ട്രിംഗ് "ആപ്പിൾ" (ദൈർഘ്യം=5) 3 => സ്ട്രിംഗ് "ഓറഞ്ച്" (ദൈർഘ്യം=6) 9 => സ്ട്രിംഗ് "ഗ്രേപ്പ്" (ദൈർഘ്യം=5) C:\OpenServer\domains\myproject.loc\www\arrays.php:9: അറേ (വലിപ്പം=3) 5 => സ്ട്രിംഗ് "മാമ്പഴം" (നീളം=5) 3 = > ചരട് "ഓറഞ്ച്" (നീളം=6) 9 => "മുന്തിരി" (നീളം=5)

അസോസിയേറ്റീവ് അറേകൾ

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

"ലേഖന ശീർഷകം", "വാചകം" => "ലേഖന വാചകം"]; $article["രചയിതാവ്"] = "രചയിതാവിൻ്റെ പേര്"; var_dump ($ലേഖനം);

ഈ കോഡിൻ്റെ ഫലം:

C:\OpenServer\domains\myproject.loc\www\arrays.php:6: അറേ (വലിപ്പം=3) "ശീർഷകം" => സ്ട്രിംഗ് "ലേഖന ശീർഷകം" (ദൈർഘ്യം=29) "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ലേഖന വാചകം" (നീളം=23) "രചയിതാവ്" => സ്ട്രിംഗ് "രചയിതാവിൻ്റെ പേര്" (ദൈർഘ്യം=19)

കൊള്ളാം, ഇപ്പോൾ നമുക്ക് ഇത് HTML മാർക്ക്അപ്പിനുള്ളിൽ ഉപയോഗിക്കാം:

"ലേഖന ശീർഷകം", "വാചകം" => "ലേഖന വാചകം", "രചയിതാവ്" => "ലേഖന രചയിതാവ്" ]; ?>

ഫലമായി:

മൾട്ടിഡൈമൻഷണൽ അറേകൾ

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

"ലേഖന ശീർഷകം", "വാചകം" => "ലേഖന വാചകം", "രചയിതാവ്" => [ "first_name" => "Ivan", "last_name" => "Ivanov" ] ]; var_dump ($ലേഖനം);

ഫലമായി:

C:\OpenServer\domains\myproject.loc\www\arrays.php:10: അറേ (വലിപ്പം=3) "ശീർഷകം" => സ്ട്രിംഗ് "ലേഖന ശീർഷകം" (ദൈർഘ്യം=29) "ടെക്സ്റ്റ്" => സ്ട്രിംഗ് "ലേഖന വാചകം" (length=23) "author" => array (size=2) "first_name" => string "Ivan" (length=8) "last_name" => string "Ivanov" (length=12)

ഇത് വളരെ ലളിതമാണ്, ലേഖനം ഒരു അറേയാണ്, രചയിതാവ് കീയിൽ ഒരു അറേ അടങ്ങിയിരിക്കുന്നു.
രചയിതാവിൻ്റെ പേര് ലഭിക്കുന്നതിന് നിങ്ങൾ ഇനിപ്പറയുന്ന കോഡ് ഉപയോഗിക്കേണ്ടതുണ്ട്:

"ലേഖന ശീർഷകം", "വാചകം" => "ലേഖന വാചകം", "രചയിതാവ്" => [ "first_name" => "Ivan", "last_name" => "Ivanov" ] ]; പ്രതിധ്വനി $ലേഖനം["രചയിതാവ്"]["first_name"];

ആദ്യം, $ലേഖന നിരയിലെ രചയിതാവിൻ്റെ കീയുടെ മൂല്യം ഞങ്ങൾക്ക് ലഭിച്ചു; ഈ മൂല്യം ഒരു അറേ ആയി മാറി. തുടർന്ന് ഈ അറേയിൽ നിന്ന് നമുക്ക് first_name കീയുടെ മൂല്യം ലഭിച്ചു. ഈ കോഡിൻ്റെ ഫലം, തീർച്ചയായും:

ഇവാൻ

നമ്മൾ ഇതിനകം ഉപയോഗിച്ച ടെംപ്ലേറ്റിൽ ഇപ്പോൾ ഈ മൂല്യങ്ങൾ ഉപയോഗിക്കാം:

"ലേഖന ശീർഷകം", "വാചകം" => "ലേഖന വാചകം", "രചയിതാവ്" => [ "first_name" => "Ivan", "last_name" => "Ivanov" ] ]; ?>

ഫലമായി:

തീർച്ചയായും, നിങ്ങൾക്ക് ഈ മൂല്യത്തിനുള്ളിൽ ഒരു അറേ സൃഷ്ടിക്കാൻ കഴിയും, അതിനുള്ളിൽ മറ്റൊന്ന്, നിങ്ങൾ അത് മടുക്കുന്നതുവരെ.

അടുത്ത പാഠത്തിൽ, അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള കൂടുതൽ സങ്കീർണ്ണവും രസകരവുമായ ഉദാഹരണങ്ങൾ നോക്കാം.

നല്ല ദിവസം, ഹബ്രാജിതെലിക്കി!

എൻ്റെ ലേഖനത്തിൽ, PHP-യിൽ മൾട്ടിഡൈമൻഷണൽ അസോസിയേറ്റീവ് അറേകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനെക്കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. എൻ്റെ അഭിപ്രായത്തിൽ, ഒരു മൾട്ടിഡൈമൻഷണൽ അറേയിൽ നിന്ന് ആവശ്യമായ വിവരങ്ങൾ നേടുന്നത് എല്ലായ്പ്പോഴും സൗകര്യപ്രദമല്ല. അറേ ദ്വിമാനമാണെങ്കിൽ അത് ഒരു കാര്യമാണ്:

അറേ ("കീ1" => "മൂല്യം1", "കീ2" => "മൂല്യം2")); ?>

അപ്പോൾ, തീർച്ചയായും, ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള മൂല്യങ്ങൾ നേടുന്നത് എളുപ്പമാണ്:

എക്കോ $array["dimension1"]["key1"]; //മൂല്യം1

എന്നാൽ നമുക്ക് ഒരു എൻ-ഡൈമൻഷണൽ അറേ ഉണ്ടെങ്കിൽ എന്തുചെയ്യും? ഉദാഹരണത്തിന്, പഞ്ചമാനം:

$array = array("dimension1" => array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\ "m value1", "value2" => "ഹേയ്! I\"m value2")))));

കീ ഉപയോഗിച്ച് മൂല്യം ലഭിക്കുന്നതിന്, ഉദാഹരണത്തിന്, “മൂല്യം1”, ഞങ്ങൾ ഇനിപ്പറയുന്ന കോഡ് എഴുതേണ്ടതുണ്ട്:

Echo $array["dimension1"]["dimension2"]["dimension3"]["dimension4"]["dimension5"]["value1"]; // ഹേയ്! ഞാൻ മൂല്യം 1 ആണ്

അത്തരമൊരു റെക്കോർഡിംഗിനെ ഞാൻ മനോഹരമായി വിളിക്കില്ല, അത് ശരിയാണെങ്കിലും. ഈ നൊട്ടേഷൻ ഇതുപോലെയാക്കി കുറച്ചുകൂടി മനോഹരമാക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു:

Echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ഹേയ്! ഞാൻ മൂല്യം 1 ആണ്

സമ്മതിക്കുക, സാധാരണ റെക്കോർഡിംഗുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഇത് വളരെ മനോഹരമായി കാണപ്പെടുന്നു.

അതിനാൽ, ആദ്യം നമ്മുടെ അറേ പ്രോസസ്സ് ചെയ്യുന്ന ഒരു ക്ലാസ് സൃഷ്ടിക്കേണ്ടതുണ്ട്. നമുക്ക് ഇതിനെ ഈസിഅറേ എന്ന് വിളിച്ച് സിംഗിൾടൺ ആക്കാം:

കോഡ്

class easyArray(പ്രൈവറ്റ് സ്റ്റാറ്റിക് $instance; // ക്ലാസ് സ്റ്റേറ്റ്. പ്രൈവറ്റ് $Array; // ക്ലാസ്സിലേക്ക് പാസ്സാക്കിയ അറേ. പ്രൈവറ്റ് ഫംഗ്‌ഷൻ __construct())( // കൺസ്ട്രക്‌റ്റർ ഫയൽ ചെയ്തു. ) സ്വകാര്യ ഫംഗ്‌ഷൻ __clone())( / / ക്ലോണിംഗ് രീതി ഫയൽ ചെയ്തു. ) പൊതു സ്റ്റാറ്റിക് ഫംഗ്‌ഷൻ getInstance())( if(null === self::$instance)( self::$instance = new self(); ) return self::$instance; )

ഞങ്ങളുടെ ക്ലാസ് സിംഗിൾടൺ ആയി മാറിയതിനുശേഷം, ഞങ്ങൾ അതിലേക്ക് വളരെ പ്രധാനപ്പെട്ട ഒരു രീതി ചേർക്കും, അത് ഫലമായുണ്ടാകുന്ന അറേയെ ഒരു സ്വകാര്യ വേരിയബിളിലേക്ക് എഴുതും:

കോഡ്

പബ്ലിക് ഫംഗ്‌ഷൻ loadArray($newArray)( if(is_array($newArray))( $this->Array = $newArray; $this തിരികെ നൽകുക; )else( $error = "ക്ഷമിക്കണം, നിങ്ങൾ ഒരു അറേ പാസാക്കിയില്ല."; പുതിയത് എറിയുക ഒഴിവാക്കൽ($പിശക്); )
കോഡിൽ നിന്ന്, മെത്തേഡ് ഇൻപുട്ടിലേക്ക് എന്താണ് നൽകിയതെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നത് കാണാം. ഇത് പാസാക്കിയ ഒരു അറേ ആയിരുന്നില്ലെങ്കിൽ, പിശക് ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു അപവാദം ഇടും " നിർഭാഗ്യവശാൽ, നിങ്ങൾ ഒരു അറേ പാസാക്കിയില്ല". പരിശോധന വിജയകരമാണെങ്കിൽ, തത്ഫലമായുണ്ടാകുന്ന അറേ ഞങ്ങൾ ഒരു സ്വകാര്യ വേരിയബിളിലേക്ക് എഴുതുകയും നിലവിലെ ഒബ്ജക്റ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു.

ശരി, ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ ക്ലാസിലെ "__get()" എന്ന മാന്ത്രിക രീതിയെ അസാധുവാക്കും. നമുക്ക് ആവശ്യമുള്ള ഫലം ലഭിക്കുന്നതിന് ഇത് ആവശ്യമാണ്. അതിനാൽ:

കോഡ്

പൊതു പ്രവർത്തനം __get($index)( if(isset($this->Aray[$index]))( if(is_array($this->Array[$index]))( $this->loadArray($this-> അറേ[$ഇൻഡക്സ്]); $this; )else($this->Aray മടക്കി[$index]; ) )else( $error = "നഷ്ടപ്പെട്ട കീ (".$index.") അറേയിൽ"; പുതിയ ഒഴിവാക്കൽ ഇടുക ($പിശക്); )

ഒന്നാമതായി, അറേയിൽ അഭ്യർത്ഥിച്ച കീയുടെ സാന്നിധ്യം ഞങ്ങൾ പരിശോധിക്കുന്നു; അത് ഇല്ലെങ്കിൽ, പിശക് ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു അപവാദം ഇടുന്നു " "നഷ്‌ടമായ കീ (".$index.") നിരയിൽ"". അടുത്തതായി, അഭ്യർത്ഥിച്ച കീ ഒരു അറേയാണോ എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു. അറേയിൽ അത്തരമൊരു കീയ്‌ക്ക് ഒരു മൂല്യമുണ്ടെങ്കിൽ, ഞങ്ങൾ ഈ മൂല്യം തിരികെ നൽകും. ഇത് ഒരു അറേ ആണെങ്കിൽ, ഞങ്ങൾ അത് " എന്നതിലേക്ക് അയയ്ക്കുന്നു. ലോഡ്അറേ($newArray)" കൂടാതെ നിലവിലെ ഒബ്ജക്റ്റ് ($ഇത്) തിരികെ നൽകുക.

കൂടാതെ, ഞങ്ങളുടെ ക്ലാസിലേക്കുള്ള അവസാന സ്പർശനമെന്ന നിലയിൽ, ഞങ്ങളുടെ ക്ലാസ് പ്രവർത്തിക്കുന്ന നിലവിലെ അറേ തിരികെ നൽകുന്ന ഒരു രീതി ചേർക്കാം:

കോഡ്

പബ്ലിക് ഫംഗ്‌ഷൻ അറേ റിട്ടേൺ() ($this->അറേ; തിരികെ നൽകുക;)

അതിനാൽ ഞങ്ങളുടെ ക്ലാസ് തയ്യാറാണ്, എന്നാൽ മൂല്യങ്ങൾ ലഭിക്കുന്നതിന് ഞങ്ങൾ ഇപ്പോൾ ഇതുപോലുള്ള കോഡ് ഉപയോഗിക്കേണ്ടതുണ്ട്:

Echo easyArray::getInstance()->loadArray($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ഹേയ്! ഞാൻ മൂല്യം 1 ആണ്

അത് പഴയതിനേക്കാൾ നീളമേറിയതായി മാറി. എന്നാൽ ഈ പ്രശ്നം പരിഹരിക്കാൻ കഴിയും, ഇതിനായി നമുക്ക് ഒരു ലളിതമായ പ്രവർത്തനം ആവശ്യമാണ്:

ഫംഗ്‌ഷൻ easyA($newArray)( ഈസിഅറേ തിരികെ നൽകുക::getInstance()->loadArray($newArray); )

ശരി, ഇപ്പോൾ നമുക്ക് ഫലം എന്താണെന്ന് പരിശോധിക്കാം:

കോഡ്

array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\"m value1", "value2" => "ഹേയ്! I\"m value2")))))); ആവശ്യം_ഒന്ന് ("easyArray.php"); ആവശ്യം_ഒന്ന് ("easyArrayFunction.php"); echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ഹേയ്! I\"m value1 echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value2; // Hey! I\"m value2 ?>
എല്ലാം ഉദ്ദേശിച്ചതുപോലെ പ്രവർത്തിക്കുന്നു.

കൂടാതെ, ഈ ക്ലാസിന് ഇനിപ്പറയുന്നതുപോലുള്ള കോൺഫിഗറേഷൻ ഫയലുകൾ കൈമാറാനാകും:

കോഡ്

array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\"m value1 file array.php", "value2" => "ഹേയ്! array.php ഫയലിൽ നിന്നുള്ള I\"m value2"))))); ?>

ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന നിർമ്മാണം ഉപയോഗിക്കേണ്ടതുണ്ട്:

കോഡ്

echo easyA(require_once("array.php"))->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ഹേയ്! array.php എന്ന ഫയലിൽ നിന്നുള്ള മൂല്യം1 ആണ് ഞാൻ

ഞാൻ വീൽ വീണ്ടും കണ്ടുപിടിച്ചിരിക്കാം, എന്നാൽ ഈ ലേഖനം തുടക്കക്കാർക്കും മറ്റ് പ്രോഗ്രാമർമാർക്കും താൽപ്പര്യമുള്ളതായിരിക്കുമെന്ന് ഞാൻ കരുതുന്നു.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി.

PHP-യിലെ അറേ ഘടകങ്ങളിൽ അക്കങ്ങൾ, സ്ട്രിംഗുകൾ, ഒബ്‌ജക്റ്റുകൾ എന്നിങ്ങനെ ഏത് തരത്തിലുള്ള മൂല്യങ്ങളും അടങ്ങിയിരിക്കാം. അവയ്ക്ക് മറ്റ് അറേകളും അടങ്ങിയിരിക്കാം, അതിനർത്ഥം സൃഷ്ടിക്കൽ എന്നാണ് ബഹുമുഖംഅഥവാ കൂടുണ്ടാക്കിഅറേ.

ഈ ട്യൂട്ടോറിയൽ മൾട്ടിഡൈമൻഷണൽ (നെസ്റ്റഡ്) PHP അറേകൾ ഉൾക്കൊള്ളുന്നു. അവ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും അവ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നും PHP-യിലെ ഒരു മുഴുവൻ മൾട്ടിഡൈമൻഷണൽ അറേയിലൂടെ എങ്ങനെ ലൂപ്പ് ചെയ്യാമെന്നും വിശദീകരിക്കുന്നു.

ഒരു മൾട്ടിഡൈമൻഷണൽ അറേ എങ്ങനെ സൃഷ്ടിക്കാം

അറേ() കൺസ്ട്രക്‌റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു മൾട്ടിഡൈമൻഷണൽ അറേ സൃഷ്‌ടിക്കാൻ കഴിയും, ഇത് ഒരു സാധാരണ അറേ സൃഷ്‌ടിക്കുന്നതിന് സമാനമാണ്. ഒരു മൾട്ടിഡൈമൻഷണൽ അറേയിൽ, ഓരോ മൂലകവും ഒരു അറേയാണ് എന്നതാണ് വ്യത്യാസം.

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

$myArray = നിര

മുകളിലുള്ള ഉദാഹരണം ഒരു ദ്വിമാന അറേ സൃഷ്ടിക്കുന്നു. ടോപ്പ് ലെവൽ അറേയിൽ 3 ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഓരോ മൂലകവും 3 മൂല്യങ്ങൾ അടങ്ങിയ ഒരു അറേയാണ്.

നിങ്ങൾക്ക് ഒരു മൾട്ടിഡൈമൻഷണൽ അറേ ആയി ഒരു അസോസിയേറ്റീവ് അറേ ഉപയോഗിക്കാനും കഴിയും. ഇനിപ്പറയുന്ന ഉദാഹരണം 3 അസോസിയേറ്റീവ് അറേകൾ അടങ്ങുന്ന ഒരു ഇൻഡക്‌സ് ചെയ്‌ത ശ്രേണിയുടെ സൃഷ്‌ടി കാണിക്കുന്നു:

$movies = array(array("title" => "Rear Window", "director" => "Alfred Hitchcock", "year" => 1954), array("title" => "Full Metal Jacket", "director " => "സ്റ്റാൻലി കുബ്രിക്ക്", "വർഷം" => 1987), അറേ("ശീർഷകം" => "മീൻ സ്ട്രീറ്റുകൾ", "സംവിധായകൻ" => "മാർട്ടിൻ സ്കോർസെസ്", "വർഷം" => 1973));

നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര ആഴത്തിൽ പരസ്പരം ഉള്ളിൽ നെസ്റ്റ് അറേകൾ കഴിയും (പ്രായോഗികമായി നെസ്റ്റിംഗ് ഡെപ്ത് അപൂർവ്വമായി 3 ലെവലിൽ കൂടുതലാണെങ്കിലും). ചുവടെയുള്ള ഉദാഹരണം ഒരു ത്രിമാന ശ്രേണി കാണിക്കുന്നു:

$myArray = array(array(array(value1 , value2), array(value3 , value4)), array(array(value5 , value6), array(value7 , value8)));

ഒരു മൾട്ടിഡൈമൻഷണൽ അറേയിലെ ഘടകങ്ങൾ ആക്സസ് ചെയ്യുന്നു

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

$myArray = അറേ(അറേ("ഒന്ന്", "രണ്ട്", "മൂന്ന്"), അറേ("നാല്", "അഞ്ച്", "ആറ്")); // "ആറ്" എക്കോ $myArray അച്ചടിക്കുക; ?>

ഞങ്ങൾ നേരത്തെ സൃഷ്‌ടിച്ച $movies മൾട്ടിഡൈമൻഷണൽ അറേയുടെ വിവിധ ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യുന്നതായി കാണിക്കുന്ന ഒരു ഉദാഹരണം ഇതാ:

എക്കോ "ആദ്യ സിനിമയുടെ പേര്:
"; echo $movies["title"] . "

"; പ്രതിധ്വനി "മൂന്നാം സിനിമയുടെ സംവിധായകൻ:
"; echo $movies["director"] . "

"; എക്കോ "ആദ്യ ഘടകത്തിൽ അടങ്ങിയിരിക്കുന്ന നെസ്റ്റഡ് അറേ:
"; print_r($movies); echo "

";

കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് ഇനിപ്പറയുന്ന ഫലം നൽകും:

ആദ്യ സിനിമയുടെ പേര്: റിയർ വിൻഡോ, മൂന്നാമത്തെ ചിത്രത്തിൻ്റെ സംവിധായകൻ: മാർട്ടിൻ സ്‌കോർസെസ് നെസ്റ്റഡ് അറേ, ആദ്യ ഘടകത്തിൽ അടങ്ങിയിരിക്കുന്നു: അറേ ( => പിൻ വിൻഡോ => ആൽഫ്രഡ് ഹിച്ച്‌കോക്ക് => 1954)

അവസാനത്തെ ഉദാഹരണം, ആദ്യ ടോപ്പ്-ലെവൽ അറേ എലമെൻ്റിലെ മുഴുവൻ നെസ്റ്റഡ് അറേയും ആക്‌സസ് ചെയ്യുന്നതിന് $movies ഉപയോഗിക്കുന്നു, തുടർന്ന് അറേയുടെ ഉള്ളടക്കങ്ങൾ പ്രിൻ്റ് ചെയ്യാൻ print_r() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു.

ഒരു മൾട്ടിഡൈമൻഷണൽ അറേയുടെ എല്ലാ ഘടകങ്ങളിലൂടെയും ഒരു ലൂപ്പ് സംഘടിപ്പിക്കുന്നു

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

1. ബാഹ്യ ലൂപ്പ് ടോപ്പ് ലെവൽ അറേയുടെ ഓരോ ഘടകങ്ങളും എടുക്കുന്നു.
2. ഓരോ ടോപ്പ് ലെവൽ എലമെൻ്റിനും, ഇൻറർ ലൂപ്പ് നെസ്റ്റഡ് അറേയിലൂടെ ആവർത്തിക്കുന്നു.

ഉദാഹരണം ഫിലിമുകളെക്കുറിച്ചുള്ള വിവരങ്ങളുള്ള ഒരു 2-ഡൈമൻഷണൽ അറേ സൃഷ്ടിക്കുന്നു, തുടർന്ന് പേജിലെ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് അറേയുടെ ഘടകങ്ങളിലൂടെ ഒരു ലൂപ്പ് സംഘടിപ്പിക്കുന്നു:

$movies = array(array("title" => "Rear Window", "director" => "Alfred Hitchcock", "year" => 1954), array("title" => "Full Metal Jacket", "director " => "സ്റ്റാൻലി കുബ്രിക്ക്", "വർഷം" => 1987), അറേ("ശീർഷകം" => "മീൻ സ്ട്രീറ്റുകൾ", "സംവിധായകൻ" => "മാർട്ടിൻ സ്കോർസെസ്", "വർഷം" => 1973)); foreach ($മൂവികൾ $movie ആയി) (എക്കോ "

"; foreach ($മൂവി $കീ ആയി => $value) (എക്കോ"

$കീ

$മൂല്യം

";) പ്രതിധ്വനി"

"; }

ഈ കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് ഇനിപ്പറയുന്ന ഫലം നൽകും:

തലക്കെട്ട് റിയർ വിൻഡോ ഡയറക്ടർ ആൽഫ്രഡ് ഹിച്ച്‌കോക്ക് വർഷം 1954 ടൈറ്റിൽ ഫുൾ മെറ്റൽ ജാക്കറ്റ് ഡയറക്ടർ സ്റ്റാൻലി കുബ്രിക്ക് വർഷം 1987 ടൈറ്റിൽ മീഡിയൻ സ്ട്രീറ്റ്സ് ഡയറക്ടർ മാർട്ടിൻ സ്കോർസെസെ വർഷം 1973

സംഗ്രഹം

ഒന്നിലധികം ഡാറ്റാബേസ് റെക്കോർഡുകൾ അല്ലെങ്കിൽ പട്ടികകളിൽ പ്രദർശിപ്പിക്കുന്നതിനുള്ള മൂല്യങ്ങൾ സംഭരിക്കുന്നത് പോലുള്ള ഏത് തരത്തിലുള്ള ഡാറ്റയും സംഭരിക്കുന്നതിന് മൾട്ടിഡൈമൻഷണൽ അറേകൾ അനുയോജ്യമാണ്. മൾട്ടിഡൈമൻഷണൽ അറേകൾ ഉപയോഗിക്കുന്നത് PHP സ്ക്രിപ്റ്റുകളുടെ പ്രവർത്തനക്ഷമത മെച്ചപ്പെടുത്തും.