നിങ്ങൾക്ക് അറേയെക്കുറിച്ച് വേണ്ടത്ര അറിവില്ലെങ്കിൽ (ആദ്യത്തെ കീ ഫൂവോ ബാറോ ആണോ എന്ന് നിങ്ങൾക്ക് ഉറപ്പില്ല), അറേയും ചിലപ്പോൾ ആയിരിക്കാം ശൂന്യം.
അതിനാൽ പരിശോധിക്കുന്നത് നന്നായിരിക്കും, പ്രത്യേകിച്ചും റിട്ടേൺ മൂല്യം ഒരു ബൂളിയൻ ഫാൾസ് ആയിരിക്കാൻ സാധ്യതയുണ്ടെങ്കിൽ:
$മൂല്യം = ശൂന്യം($arr) ? $default: reset($arr);
മുകളിലുള്ള കോഡ് റീസെറ്റും മറ്റും ഉപയോഗിക്കുന്നു പാർശ്വഫലങ്ങൾ ഉണ്ട്(ഇത് ഇൻ്റേണൽ അറേ പോയിൻ്റർ പുനഃസജ്ജമാക്കുന്നു) അതിനാൽ അറേയുടെ ആദ്യ ഘടകത്തിൻ്റെ ഒരു പകർപ്പ് വേഗത്തിൽ ആക്സസ് ചെയ്യുന്നതിന് നിങ്ങൾ array_slice ഉപയോഗിക്കാൻ താൽപ്പര്യപ്പെട്ടേക്കാം:
$മൂല്യം = $ default; foreach(array_slice($arr, 0, 1) $value ആയി);
നിങ്ങൾക്ക് എന്താണ് ലഭിക്കേണ്ടതെന്ന് ഊഹിക്കുക കീയും മൂല്യവും വെവ്വേറെ, നിങ്ങൾ array_slice-ലേക്ക് നാലാമത്തെ പാരാമീറ്റർ ചേർക്കേണ്ടതുണ്ട്:
Foreach(array_slice($arr, 0, 1, true) as $key => $value);
ആദ്യ ഘടകം ലഭിക്കാൻ ഒരു ജോഡിയായി(കീ => മൂല്യം):
$item = array_slice($arr, 0, 1, true);
നേടാനുള്ള ലളിതമായ പരിഷ്ക്കരണം അവസാനത്തെഘടകം, കീ, മൂല്യം എന്നിവ വെവ്വേറെ:
Foreach(array_slice($arr, -1, 1, true) as $key => $value);
കളിക്കുക
അറേ വളരെ വലുതല്ലെങ്കിൽ, നിങ്ങൾക്ക് ശരിക്കും array_slice ആവശ്യമില്ല, കൂടാതെ നിങ്ങൾക്ക് മുഴുവൻ കീ അറേയുടെയും ഒരു പകർപ്പ് നേടാനും തുടർന്ന് ആദ്യത്തെ ഘടകം നേടാനും കഴിയും:
$കീ = എണ്ണം ($arr) ? array_keys($arr) : null;
എന്നിരുന്നാലും, നിങ്ങൾക്ക് വളരെ വലിയ അറേ ഉണ്ടെങ്കിൽ, array_slice-നേക്കാൾ കാര്യമായ സമയവും കൂടുതൽ മെമ്മറിയും ആവശ്യമായി വരും array_keys (രണ്ട് ഫംഗ്‌ഷനുകളും അറേയിലൂടെ കടന്നുപോകുന്നു, എന്നാൽ array_slice-ന് ആവശ്യമായ ഘടകങ്ങൾ ഉള്ളപ്പോൾ രണ്ടാമത്തേത് പുറത്തുകടക്കുമ്പോൾ - അതായത് ഒന്ന്).
വളരെ വലുതും വളഞ്ഞുപുളഞ്ഞതുമായ ഒരു വസ്തുവിനെ ചൂണ്ടിക്കാണിക്കുന്ന ഒരു ആദ്യ സൂചന നിങ്ങൾക്ക് ലഭിക്കുമ്പോഴാണ് ശ്രദ്ധേയമായ ഒരു അപവാദം. ഈ സാഹചര്യത്തിൽ, array_slice ആ ആദ്യത്തെ വലിയ ഒബ്‌ജക്‌റ്റ് ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യും, കൂടാതെ array_keys കീകൾ മാത്രം പിടിച്ചെടുക്കും.
PHP 7.3
PHP 7.3 array_key_first(), array_key_last() എന്നിവ നടപ്പിലാക്കുന്നു. അറേയുടെ ആന്തരിക അവസ്ഥ ഒരു പാർശ്വഫലമായി പുനഃസജ്ജീകരിക്കാതെ തന്നെ ആദ്യത്തേയും അവസാനത്തേയും കീകൾ കാര്യക്ഷമമായി ആക്സസ് ചെയ്യാൻ അവ വ്യക്തമായി നൽകിയിരിക്കുന്നു.
അതിനാൽ PHP 7.3-ൽ $array യുടെ ആദ്യ മൂല്യം ആക്സസ് ചെയ്യാൻ കഴിയും
$അറേ;
അറേ ശൂന്യമല്ലെന്ന് നിങ്ങൾ പരിശോധിക്കുന്നതാണ് നല്ലത്, അല്ലാത്തപക്ഷം നിങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കും:
$firstKey = array_key_first($array); എങ്കിൽ (null === $firstKey) ( $value = "Array ശൂന്യമാണ്"; // An error should be handled here } else { $value = $array[$firstKey]; }!}
2018 ലോകകപ്പിലെ ഹീറോയ്ക്കുള്ള ചുവപ്പ് കാർഡ്, സ്റ്റോപ്പേജ് ടൈമിൽ ഇതിനകം സംഭവിച്ചു. കൂടുതൽ വ്യക്തമായി പറഞ്ഞാൽ, അവസാനം.
റൊമാനിയൻ റഫറി ഒവിഡിയു ഹാറ്റ്‌സെഗൻ ചേർത്ത നാലെണ്ണം അവസാനിച്ചു (അല്ലെങ്കിൽ അവസാനിച്ചു പോലും), ദേശീയ ടീമിൻ്റെ ഗോൾകീപ്പർ... ഓ, ഇല്ല, റഷ്യൻ ദേശീയ ടീമല്ല, അക്കിൻഫീവ് അടുത്തിടെ ദേശീയ ടീമിനായി കളിച്ചു, ചില കാരണങ്ങളാൽ അദ്ദേഹം ജഡ്ജിയോട് എന്തെങ്കിലും തെളിയിക്കാൻ തിരക്കി.
എന്നോട് പറയൂ, സ്റ്റാറ്റിസ്റ്റിക്കൽ പിശകിൻ്റെ ചട്ടക്കൂടിനുള്ളിലെ വ്യക്തിഗത കേസുകൾ ഒഴികെ, ആരാണ്, എപ്പോൾ, അത്തരമൊരു സാഹചര്യത്തിൽ നീതി തേടി? (കൂടാതെ, ഇഗോർ ഇവിടെ നീതി എന്നതുകൊണ്ട് എന്താണ് ഉദ്ദേശിച്ചതെന്ന് പറയാൻ പ്രയാസമാണ്: ശരി, മാഡ്രിഡ് ടീമിൻ്റെ ഭാഗത്തുനിന്ന് ഏതെങ്കിലും തരത്തിലുള്ള ഫൗൾ ഉണ്ടായിട്ടുണ്ടെങ്കിലും, അതെല്ലാം മൂല്യവത്താണോ?).
മിക്കപ്പോഴും അവർ മറ്റെന്തെങ്കിലും നേടുന്നു - ഒരു മഞ്ഞ അല്ലെങ്കിൽ ചുവപ്പ് കാർഡ്.
Akinfeev രണ്ടും സ്വീകരിച്ചു. ആദ്യം - ഒരു മഞ്ഞ, പിന്നെ - അവൻ്റെ ആവേശകരമായ വേലിയേറ്റം തുടരുന്നു - അയാൾക്ക് മറ്റൊന്ന് ലഭിച്ചു, തുടർന്ന് - അതനുസരിച്ച്, ചുവപ്പ്.
ഗോൾകീപ്പർ കൃത്യമായി എന്താണ് പറഞ്ഞത്? കൃത്യമായി ഏത് ഭാഷയിലാണ്: ഇംഗ്ലീഷ്, റൊമാനിയൻ, റഷ്യൻ? അവൻ അസഭ്യം ഉപയോഗിച്ചോ ഇല്ലയോ?
ഇഗോറിനും എപ്പിസോഡിനോട് ഏറ്റവും അടുത്ത സഖാക്കൾക്കും ഒഴികെ മറ്റാർക്കും കൃത്യമായി അറിയില്ല. എന്നാൽ അവർ എല്ലാം പറയാൻ സാധ്യതയില്ല.
എനിക്ക് ഒരു കാര്യം ഉറപ്പുണ്ട്: കായിക, കായിക സമൂഹം ഇത് വളരെക്കാലമായി ചർച്ച ചെയ്യും. 2006 ലോകകപ്പിൻ്റെ ഫൈനലിൽ ഫ്രഞ്ച് താരം സിനദീൻ സിദാനെ ഇതിഹാസമായി പുറത്താക്കിയ ഇറ്റാലിയൻ മാർക്കോ മറ്റെരാസിയുടെ വാചകം പോലെ...
അതെന്തായാലും, അകിൻഫീവ് ടീമിനെ നിരാശപ്പെടുത്തി. ഇനി ചാമ്പ്യൻസ് ലീഗിലെ പ്രധാനപ്പെട്ട ഒരു മത്സരമെങ്കിലും അദ്ദേഹത്തിന് നഷ്ടമാകും. റോമിൽ നടക്കുന്ന ഗ്രൂപ്പ് ടൂർണമെൻ്റിൻ്റെ മൂന്നാം റൗണ്ടിൽ.
ഇനിയുണ്ടാകില്ലെന്ന് ഞാൻ പ്രതീക്ഷിക്കാൻ ആഗ്രഹിക്കുന്നു: സാധാരണയായി രണ്ട് മുന്നറിയിപ്പുകൾക്കുള്ള ചുവപ്പ് കാർഡ് മറ്റൊന്നും അർത്ഥമാക്കുന്നില്ല.
എന്നിരുന്നാലും, ഈ അകിൻഫീവ്സ്കി നീക്കം ഗംഭീരമായ ഒരു ഫുട്ബോൾ ചാമ്പ്യൻഷിപ്പ് പോരാട്ടത്തിൻ്റെ അവസാന എപ്പിസോഡ് മാത്രമായിരുന്നു. അല്ലെങ്കിൽ - ഏതാണ്ട് അവസാനത്തേത്: റിസർവ് ഗോൾകീപ്പറായ 20 കാരനായ ജോർജി കിർനാറ്റ്‌സിനായി ഒരു നേരായ സിനിമാറ്റിക് പകരക്കാരനും ഉണ്ടായിരുന്നു (വിക്ടർ മിഖൈലോവിച്ച് ഗഞ്ചരെങ്കോ, ഭാഗ്യവശാൽ, അവൻ്റെ സ്ലീവ് ഒന്ന് മുകളിലേക്ക് ഉപേക്ഷിച്ചു). 5 വയസ്സുള്ളപ്പോൾ ഒരു ഫുട്ബോൾ കളിക്കാരനെന്ന നിലയിൽ അദ്ദേഹത്തിൻ്റെ കരിയർ പൊതുജനങ്ങൾക്ക് അറിയാൻ സാധ്യതയില്ല ... സ്പാർട്ടക് സോക്കോൾനിക്കിയിൽ.
എന്നാൽ കിർനാറ്റ്‌സ് ഗോളിൽ നിന്ന് പന്ത് തട്ടിയിട്ടുപോലുമില്ല. കൂടുതൽ പരിചയസമ്പന്നരായ പങ്കാളികൾ, യുവ ഗോൾകീപ്പർക്ക് മതിയായ അനുഭവപരിചയം ഉണ്ടായിരിക്കില്ലെന്ന് യുക്തിസഹമായി ന്യായവാദം ചെയ്തു (നിർണായക നിമിഷത്തിൽ അവൻ പ്രലോഭിപ്പിക്കപ്പെടും!). അല്ലെങ്കിൽ ശാരീരിക ശക്തി പോലും, പ്രത്യേകിച്ച് ചൂടാക്കാൻ സമയമില്ലാത്തതിനാൽ.
വഴിയിൽ, അദ്ദേഹത്തിന് പകരം വയ്ക്കാൻ തയ്യാറായ ആർമി കളിക്കാരനായ അസ്റ്റെമിർ ഗോർഡ്യുഷെങ്കോയെ നീക്കം ചെയ്തതിൽ സഹതപിക്കാൻ അവശേഷിക്കുന്നു: റയലിനെതിരായ വിജയത്തിൽ ആ വ്യക്തി പങ്കെടുത്തില്ല.
ഈ വിജയത്തെ ചരിത്രപരമെന്ന് വിളിക്കണമെന്നതിൽ സംശയമില്ല. എന്നിരുന്നാലും, ഉദാഹരണത്തിന്, മോസ്കോ "സ്പാർട്ടക്", 98-ൻ്റെ ശരത്കാലത്തിൽ അതേ "റിയൽ" തോൽപ്പിച്ചപ്പോൾ (ഇരുപത്, ചിന്തിക്കാൻ ഭയാനകമാണ്, വർഷങ്ങൾക്ക് മുമ്പ്), ലെവലിൻ്റെ കാര്യത്തിൽ ഭൂഖണ്ഡത്തിലെ ഭീമന്മാരുമായി വളരെ അടുത്തായിരുന്നു: മൂന്ന് വർഷം 1995/96 ചാമ്പ്യൻസ് ലീഗ് ഗ്രൂപ്പിലെ 6 മത്സരങ്ങളിലെ 6 വിജയങ്ങൾക്ക് ശേഷം വിജയിച്ചില്ല!
പ്രധാന യൂറോപ്യൻ ഫുട്ബോൾ ടൂർണമെൻ്റിൻ്റെ പ്രധാന നറുക്കെടുപ്പിൽ CSKA എപ്പോഴെങ്കിലും അത്തരം ശ്രദ്ധേയമായ പോരാട്ടങ്ങളിൽ വിജയിച്ചിട്ടുണ്ടോ? എൻ്റെ അഭിപ്രായത്തിൽ, ഇല്ല.
മറ്റ് ടൂർണമെൻ്റുകളിൽ ഇത് തീർച്ചയായും സംഭവിച്ചു. അതെ, അത് സാധ്യമാണ്, സ്റ്റമ്പ് വ്യക്തമാണ്, ഓർക്കാൻ, ആദ്യത്തെ ചാമ്പ്യൻസ് ലീഗിലേക്കുള്ള തിരഞ്ഞെടുപ്പും ബാഴ്‌സലോണയിലെ ഒരു അത്ഭുതകരമായ വിജയവും (അതുപോലെ, അന്നത്തെ ട്രോഫി ജേതാവിനേക്കാൾ). കൊള്ളാം, ചാമ്പ്യൻസ് ലീഗ് പ്ലേഓഫുകൾ, സെവിയ്യയുമായുള്ള രണ്ട് മീറ്റിംഗുകളുടെ ആകെത്തുകയിലെ വിജയമാണ് ഏറ്റവും ശ്രദ്ധേയമായത്, ഒരുകാലത്ത് സൈനിക ടീമിനെ ക്വാർട്ടർ ഫൈനലിലെത്തിച്ചു...
എന്നാൽ വിക്ടർ ഗഞ്ചരെങ്കോയുടെ കരിയറിൽ വ്യക്തിപരമായി, ഗ്രൂപ്പിൽ വ്യത്യസ്തമായ എന്തെങ്കിലും സംഭവിച്ചു: ഉദാഹരണത്തിന്, BATE (എളിമയുള്ള നഗരമായ ബോറിസോവിൽ നിന്നുള്ള യൂറോപ്യൻ നിലവാരത്തിലുള്ള ഒരു മിതമായ ടീം, ബെലാറഷ്യൻ നിലവാരത്തിൽ പോലും), അദ്ദേഹം വിജയിച്ചു - 35 വയസ്സിൽ! - ബയേൺ മ്യൂണിക്. അതേ ചാമ്പ്യൻസ് ലീഗ് നറുക്കെടുപ്പിൽ ജർമ്മൻകാർ ഒടുവിൽ പ്രധാന സമ്മാനം നേടി...
വിക്ടർ മിഖൈലോവിച്ചിൻ്റെ അടുത്ത യൂറോപ്യൻ വിജയത്തെക്കുറിച്ച് ചർച്ച ചെയ്യുമ്പോൾ നിങ്ങളും ഞാനും ഏതെല്ലാം കാരണങ്ങൾ ശ്രദ്ധിക്കണം - തീർച്ചയായും അദ്ദേഹത്തിൻ്റെ സ്വന്തം കഴിവുകൾ കൂടാതെ?
ഒന്നാമതായി, അവസാനത്തെ നാഡീ തകരാർ കണക്കിലെടുക്കാതെ അകിൻഫീവ് മികച്ച രീതിയിൽ കളിച്ചു. രണ്ടാമതായി, റയൽ മാഡ്രിഡ് ഏറ്റവും ശക്തമായ സ്ക്വാഡുമായി എത്തിയില്ല (ഉദാഹരണത്തിന്, ഡിഫൻഡർ സെർജിയോ റാമോസ് ഇല്ലാതെ, ലെഫ്റ്റ് ഫ്ലാങ്ക് ബ്രസീലിയൻ മാർസെലോ ഇല്ലാതെ, ആക്രമണത്തിൻ്റെ നായകന്മാരിൽ ഒരാളായ വെൽഷ്മാൻ ഗാരെത് ബെയ്ൽ ഇല്ലാതെ; മറുവശത്ത്, നിങ്ങളല്ലേ? ക്രൊയേഷ്യൻ ദേശീയ ടീമിനെ 2018 ലോകകപ്പ് ഫൈനലിലെത്തിച്ച ലൂക്കാ മോഡ്രിച്ച്, സ്പാനിഷ് താരം അസെൻസിയോ, ജർമ്മൻ ടോണി ക്രൂസ്, ഫ്രഞ്ച് താരം റാഫേൽ വരാനെ, കോസ്റ്റാറിക്കൻ ഗോൾകീപ്പർ കീലർ നവാസ് തുടങ്ങിയ ലോക ഫുട്ബോൾ താരങ്ങൾ മതിയോ?).
കൂടാതെ, മാഡ്രിഡ് ബ്രസീലിയൻ കാസെമിറോയെയും ഫ്രഞ്ചുകാരൻ കരിം ബെൻസെമയെയും തട്ടിയ ക്രോസ്ബാറുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ എവിടെയോ ഭാഗ്യവാന്മാരായിരുന്നു, കൂടാതെ നിക്കോള വ്ലാസിച്ചിൻ്റെ പെട്ടെന്നുള്ള ഗോളിലൂടെ - നമ്മുടെ ക്രൊയേഷ്യൻ ഇതിനകം തന്നെ സമ്മാനം ലഭിച്ച ഇതിഹാസ സ്വഹാബിയെ നേരിട്ട് മറച്ചുവച്ചു. ലോകത്തിലെ ഏറ്റവും മികച്ച കളിക്കാരൻ.
എന്നാൽ ഒരു ഗോൾ നേടിയത് ഒരു ഗോളായിരുന്നു, അതിനുശേഷം ഞങ്ങൾക്ക് റയൽ മാഡ്രിഡുമായി തന്നെ പോരാടേണ്ടി വന്നു, ഡ്യുവലുകൾ നേടി. കൂടാതെ വ്യക്തമായി പ്രതിരോധ പുനർനിർമ്മാണങ്ങൾ നിർമ്മിക്കുന്നു. അത് നന്നായി ചെയ്യുന്നതിൽ സെസ്കോവൈറ്റ്സ് വിജയിച്ചു.
ഒപ്പം - 2018 ലെ നമ്മുടെ ഹോം ലോകകപ്പിനെക്കുറിച്ചുള്ള മറ്റൊരു പരാമർശം. അവസാന വിസിലിനോട് അടുത്ത്, ഒരു തമാശ മനസ്സിൽ വന്നു: “ലോകകപ്പ് ആരംഭിക്കുന്നതിന് മുമ്പുള്ള അദ്ദേഹത്തിൻ്റെ പുറത്താക്കൽ പോലും ജൂലൻ ലോപെറ്റെഗിയെ രക്ഷിച്ചില്ല (കൃത്യമായി റയലിലേക്ക് പോയത് കൊണ്ടാണ് സ്പാനിഷ് ദേശീയ ടീമിൽ നിന്ന് അദ്ദേഹത്തെ ആവശ്യപ്പെട്ടതെന്ന് ഓർക്കുക. "ലുഷ്‌നികി"യിലെ തോൽവിയിൽ നിന്ന് അവൻ്റെ സാധനങ്ങളുമായി സമയം?)
ഇത്തവണ എല്ലാം അവസാനിച്ചത് “ദൈവത്തിൻ്റെ പാദത്തിൽ” അല്ല, മറിച്ച് അക്കിൻഫീവിൻ്റെ മണ്ടത്തരത്തോടെയാണ് - എനിക്ക് വിശ്വസിക്കാൻ ആഗ്രഹമുണ്ട്, ഞാൻ വീണ്ടും പറയും, ഇത് എനിക്ക് 1 മത്സര അയോഗ്യത നൽകുമെന്ന്!
Reg.ru: ഡൊമെയ്‌നുകളും ഹോസ്റ്റിംഗും
റഷ്യയിലെ ഏറ്റവും വലിയ രജിസ്ട്രാറും ഹോസ്റ്റിംഗ് ദാതാവും.
2 ദശലക്ഷത്തിലധികം ഡൊമെയ്ൻ നാമങ്ങൾ സേവനത്തിലുണ്ട്.
പ്രമോഷൻ, ഡൊമെയ്ൻ മെയിൽ, ബിസിനസ്സ് സൊല്യൂഷനുകൾ.
ലോകമെമ്പാടുമുള്ള 700 ആയിരത്തിലധികം ഉപഭോക്താക്കൾ ഇതിനകം അവരുടെ തിരഞ്ഞെടുപ്പ് നടത്തി.
ബൂട്ട്സ്ട്രാപ്പ് ചട്ടക്കൂട്: വേഗത്തിലുള്ള അഡാപ്റ്റീവ് ലേഔട്ട്
ബൂട്ട്സ്ട്രാപ്പ് ചട്ടക്കൂടിലെ അഡാപ്റ്റീവ് ലേഔട്ടിൻ്റെ അടിസ്ഥാനങ്ങളെക്കുറിച്ചുള്ള ഘട്ടം ഘട്ടമായുള്ള വീഡിയോ കോഴ്‌സ്.
ശക്തവും പ്രായോഗികവുമായ ഉപകരണം ഉപയോഗിച്ച് ലളിതമായും വേഗത്തിലും കാര്യക്ഷമമായും ടൈപ്പ് സെറ്റിംഗ് പഠിക്കുക.
ഓർഡർ ചെയ്യാനും പണം നേടാനുമുള്ള ലേഔട്ട്.
*സ്ക്രോളിംഗ് താൽക്കാലികമായി നിർത്താൻ മൗസ് ഓവർ ചെയ്യുക.
തിരികെ മുന്നോട്ട്
PHP: അറേ ഘടകങ്ങൾ നീക്കം ചെയ്യുന്നു
നിസ്സാരമെന്ന് തോന്നുന്ന ഒരു ജോലിയാണ് ഞങ്ങൾ നേരിടുന്നത്: ഒരു അറേ ഘടകം നീക്കം ചെയ്യുക. അല്ലെങ്കിൽ നിരവധി ഘടകങ്ങൾ.
എന്നിരുന്നാലും, അതിൻ്റെ എല്ലാ ലാളിത്യത്തിനും, പൂർണ്ണമായും വ്യക്തമല്ലാത്ത ഓപ്ഷനുകളുണ്ട്, കൂടാതെ "ഹലോ, വേൾഡ്!" എന്നതിനേക്കാൾ കുറച്ചുകൂടി മുന്നോട്ട് പോകാൻ നിങ്ങൾക്ക് PHP ആവശ്യമുണ്ടോ എന്ന് അറിയേണ്ടതാണ്. :)
നമുക്ക് അടിസ്ഥാനം തന്നെ ആരംഭിക്കാം: ഒരു ഘടകം നീക്കംചെയ്യാൻ, നിങ്ങൾ ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട് അൺസെറ്റ് ():
അൺസെറ്റ്($അറേ); അൺസെറ്റ്($അറേ["ഫൂ"]);
അൺസെറ്റ് ($അറേ, $അറേ); അൺസെറ്റ്($array["foo"], $array["bar"]);
അടുത്ത ലോജിക്കൽ ചോദ്യം ഇതാണ്: പരസ്പരം പിന്തുടരുന്ന (അതായത് തൊട്ടടുത്തുള്ള) ഒന്നിലധികം ഘടകങ്ങൾ എങ്ങനെ ഇല്ലാതാക്കാം? ഒന്നിലധികം അടുത്തുള്ള ഘടകങ്ങൾ നീക്കം ചെയ്യാൻ, ഫംഗ്ഷൻ ഉപയോഗിക്കുക array_spice():
Array_splice($array, $offset, $length);
ഈ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, ഈ ഘടകങ്ങളെക്കുറിച്ചുള്ള എല്ലാ റഫറൻസുകളും അപ്രത്യക്ഷമാകുമെന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾക്ക് അറേയിൽ ഒരു കീ ഇടുകയും എന്നാൽ അതിനെ ഒരു ശൂന്യമായ മൂല്യവുമായി ബന്ധപ്പെടുത്തുകയും ചെയ്യണമെങ്കിൽ, ആവശ്യമുള്ള ഘടകം ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് അസൈൻ ചെയ്യുക:
$array = $array["foo"] = "";
പ്രവർത്തനമാണെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ് അൺസെറ്റ് ()മൂലകത്തെ നീക്കം ചെയ്യുന്നു, അതേസമയം ഘടകത്തിലേക്ക് "" അസൈൻ ചെയ്യുന്നത് അത് നീക്കം ചെയ്യുന്നില്ല, പക്ഷേ അതിൻ്റെ മൂല്യം ശൂന്യമായ സ്ട്രിംഗിന് തുല്യമാക്കുന്നു.
നിങ്ങൾ അക്കങ്ങൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുകയാണെങ്കിൽ, അത്തരമൊരു കീയുമായി മൂല്യം 0 ബന്ധപ്പെടുത്തുന്നതാണ് നല്ലത്.
നമുക്ക് പറയാം, ഒരു കമ്പനി HBL-568 മോഡലിൻ്റെ ഭാഗങ്ങൾ നിർമ്മിക്കുന്നത് നിർത്തിയാൽ, പാർട്സ് അറേയിൽ ഒരു മാറ്റം വരുത്താം:
സജ്ജീകരിക്കാത്തത്($products["HBL-568"]);
HBL-568 ഭാഗം താൽക്കാലികമായി മാത്രം സ്റ്റോക്കിൽ ഇല്ലെങ്കിൽ ഫാക്ടറിയിൽ നിന്ന് എത്തുമെന്ന് പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, അങ്ങനെ ചെയ്യുന്നതാണ് നല്ലത്:
$products["HBL-568"] = 0;
മനസ്സിലാക്കേണ്ട അടുത്ത പോയിൻ്റ് ഒരു ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ എന്നതാണ് അൺസെറ്റ് ()ഒരു അറേ എലമെൻ്റിനായി, പിഎച്ച്പി അറേ ക്രമീകരിക്കുന്നു, അങ്ങനെ ലൂപ്പ് ഇപ്പോഴും ശരിയായി പ്രവർത്തിക്കുന്നു.
മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, തത്ഫലമായുണ്ടാകുന്ന "ദ്വാരങ്ങൾ" പൂരിപ്പിക്കുന്നതിന് അറേ കംപ്രസ് ചെയ്തിട്ടില്ല. അടിസ്ഥാനപരമായി, എല്ലാ അറേകളും ഒറ്റനോട്ടത്തിൽ സംഖ്യാപരമായി തോന്നുകയാണെങ്കിൽപ്പോലും അസോസിയേറ്റീവ് ആണെന്നാണ് ഇതിനർത്ഥം. ഈ സ്വഭാവം വ്യക്തമാക്കുന്നതിന് വ്യക്തമായ ഉദാഹരണങ്ങൾ നോക്കാം:
// ഒരു "സംഖ്യാ" അറേ സൃഷ്ടിക്കുക $മൃഗങ്ങൾ = അറേ("ഉറുമ്പ്", "തേനീച്ച", "പൂച്ച", "നായ", "എൽക്ക്", "കുറുക്കൻ"); പ്രിൻ്റ് $മൃഗങ്ങൾ; // "തേനീച്ച" പ്രിൻ്റ് $മൃഗങ്ങൾ; // "പൂച്ച" എണ്ണം ($മൃഗങ്ങൾ) പ്രിൻ്റ് ചെയ്യുന്നു; // റിട്ടേണുകൾ 6 // unset() unset($മൃഗങ്ങൾ); // ഒരു മൂലകം നീക്കം ചെയ്യുന്നു $മൃഗങ്ങൾ = "തേനീച്ച" പ്രിൻ്റ് $മൃഗങ്ങൾ; // ഒന്നും ഔട്ട്പുട്ട് ചെയ്യുന്നില്ല, ഒരു പിശക് നൽകുന്നു E_NOTICE പ്രിൻ്റ് $മൃഗങ്ങൾ; // "പൂച്ച" എണ്ണം ($മൃഗങ്ങൾ) പ്രിൻ്റ് ചെയ്യുന്നു; // $array ഘടകം നിലനിൽക്കുമ്പോൾ 5 നൽകുന്നു ഒപ്പം "ഫോക്സ്" അടങ്ങിയിരിക്കുന്നു // ഒരു പുതിയ ഘടകം ചേർക്കുന്നു $animals = "gnu"; // ഒരു പുതിയ ഘടകം പ്രിൻ്റ് $അനിമൽസ് ചേർക്കുന്നു; // ഒന്നും പ്രിൻ്റ് ചെയ്യുന്നില്ല, ഒരു പിശകും നൽകുന്നു E_NOTICE പ്രിൻ്റ് $അനിമൽസ്; // പ്രിൻ്റുകൾ "ഗ്നു" എണ്ണം ($മൃഗങ്ങൾ); // റിട്ടേണുകൾ 6 // "" (ശൂന്യമായ സ്ട്രിംഗ്) $അനിമൽസ് = "" അസൈൻ ചെയ്യുന്നു; // "ശൂന്യമായ സ്ട്രിംഗ്" പ്രിൻ്റ് $ആനിമൽസ് ആയി സജ്ജമാക്കുക; // പ്രിൻ്റുകൾ "" എണ്ണം ($മൃഗങ്ങൾ); // റിട്ടേണുകൾ 6, അതായത്. എണ്ണുമ്പോൾ ശൂന്യമായ അറേ ഘടകം കണക്കിലെടുക്കുന്നു
ജനസാന്ദ്രതയുള്ള ഒരു സംഖ്യാ ശ്രേണിയിലെത്താൻ, ഫംഗ്ഷൻ ഉപയോഗിക്കുക array_values():
$മൃഗങ്ങൾ = array_values($മൃഗങ്ങൾ);
കൂടാതെ, array_splice() ഫംഗ്ഷൻ “ദ്വാരങ്ങൾ” ഇല്ലാതാക്കാൻ അറേകളെ യാന്ത്രികമായി റീഇൻഡക്‌സ് ചെയ്യുന്നു:
// ഒരു "സംഖ്യാ" അറേ സൃഷ്ടിക്കുക $മൃഗങ്ങൾ = അറേ("ഉറുമ്പ്", "തേനീച്ച", "പൂച്ച", "നായ", "എൽക്ക്", "കുറുക്കൻ"); array_splice($മൃഗങ്ങൾ, 2, 2); print_r ($ മൃഗങ്ങൾ);
ഔട്ട്പുട്ടിൽ നമുക്ക് ലഭിക്കുന്നത്:
അറേ ( => ഉറുമ്പ് => തേനീച്ച => എൽക്ക് => കുറുക്കൻ)
ഈ സവിശേഷത എവിടെ ഉപയോഗപ്രദമാകും?
നിങ്ങൾ ഒരു ക്യൂവായി ഒരു അറേയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നുണ്ടെന്നും ക്രമരഹിതമായ ആക്‌സസ്സിൻ്റെ സാധ്യത നഷ്‌ടപ്പെടാതെ ഈ ക്യൂവിൽ നിന്ന് ഘടകങ്ങൾ നീക്കംചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെന്നും പറയട്ടെ, ഫലമായുണ്ടാകുന്ന "ദ്വാരങ്ങളിൽ" നിങ്ങൾ ആകസ്‌മികമായി വീഴുമ്പോൾ.
അവസാനമായി, ഒരു അറേയിൽ നിന്ന് ആദ്യത്തെയോ അവസാനത്തെയോ ഘടകം സുരക്ഷിതമായി നീക്കംചെയ്യുന്നതിന്, പ്രവർത്തനങ്ങൾ array_shift()ഒപ്പം array_pop()യഥാക്രമം.
അവരുമായി എല്ലാം വളരെ ലളിതമാണ്:
$ സ്റ്റാക്ക് = അറേ ("ഓറഞ്ച്", "വാഴപ്പഴം", "ആപ്പിൾ", "റാസ്ബെറി"); $fruit = array_shift($stack); print_r ($ സ്റ്റാക്ക്);
മുകളിലുള്ള കോഡ് എക്സിക്യൂട്ട് ചെയ്തതിൻ്റെ ഫലമായി, നമുക്ക് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ലഭിക്കും:
അറേ ( => വാഴപ്പഴം => ആപ്പിൾ => റാസ്ബെറി)
അവസാന ഘടകം നീക്കംചെയ്യുന്നതിന്, ഫംഗ്ഷൻ ഉപയോഗിക്കുക array_pop():
$ സ്റ്റാക്ക് = അറേ ("ഓറഞ്ച്", "വാഴപ്പഴം", "ആപ്പിൾ", "റാസ്ബെറി"); $fruit = array_pop($stack); print_r ($ സ്റ്റാക്ക്);
ഔട്ട്പുട്ട് ഇനിപ്പറയുന്ന അറേ പ്രിൻ്റൗട്ടാണ്:
അറേ ( => ഓറഞ്ച് => വാഴപ്പഴം => ആപ്പിൾ)
അത്രയേയുള്ളൂ. പിഎച്ച്പിയിലെ അറേ ഘടകങ്ങൾ ഇല്ലാതാക്കുന്നതിനുള്ള പ്രധാന പോയിൻ്റുകൾ ഞങ്ങൾ ചർച്ച ചെയ്തു. എന്തെങ്കിലും സംഭവിക്കുകയാണെങ്കിൽ, ഔദ്യോഗിക ഡോക്യുമെൻ്റേഷൻ എപ്പോഴും സഹായകരമാണ്.
നിങ്ങൾക്ക് മെറ്റീരിയൽ ഇഷ്ടപ്പെട്ടോ, എന്നോട് നന്ദി പറയണോ?
നിങ്ങളുടെ സുഹൃത്തുക്കളുമായും സഹപ്രവർത്തകരുമായും പങ്കിടുക!
ഇതും കാണുക:
ഡാറ്റ ഓർഗനൈസുചെയ്യാനും ഉപയോഗിക്കാനുമുള്ള ഒരു മാർഗമാണ് PHP അറേകൾ. ലളിതമായി പറഞ്ഞാൽ, ഒരു അറേ ഒരു പട്ടികയാണ്. ഗതാഗത രീതികളുടെ പേരുകളുള്ള ഒരു അറേയുടെ ഒരു ചെറിയ ഉദാഹരണം ഇതാ:
$ ഗതാഗതം = അറേ ('വിമാനങ്ങൾ', 'ട്രെയിനുകൾ', 'ഓട്ടോമൊബൈലുകൾ');
വായിക്കുന്നത് എളുപ്പമാക്കുന്നതിന്, നിങ്ങൾക്ക് ഇത് ഇതുപോലെ എഴുതാം:
$ ഗതാഗതം = അറേ ('വിമാനങ്ങൾ', 'ട്രെയിനുകൾ', 'ഓട്ടോമൊബൈലുകൾ');
$transportation വേരിയബിളിൽ ഇപ്പോൾ ഗതാഗത രീതികളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു.
അറേ ഘടകങ്ങൾ അച്ചടിക്കുന്നു
മുകളിലുള്ള പട്ടികയിലെ ഓരോ ഘടകങ്ങളെയും ഒരു മൂല്യം എന്ന് വിളിക്കുന്നു. ഓരോ മൂല്യത്തിനും ഒരു കീ ഉണ്ട്. ഘടകത്തിനായി നിങ്ങൾ സ്വയം ഒരു കീ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, അത് സ്വയമേവ നിയുക്തമാക്കും, ഇത് ഒരു സീരിയൽ നമ്പറായിരിക്കും. PHP അറേകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ചുവടെ:
$ ഗതാഗതം = അറേ(0 => 'വിമാനങ്ങൾ', 1 => 'ട്രെയിനുകൾ', 2 => 'ഓട്ടോമൊബൈലുകൾ');
=> ഒരു അസൈൻമെൻ്റ് ഓപ്പറേറ്ററാണ്, അക്കങ്ങൾ കീകളാണ്. ഞങ്ങൾ 0-ൽ ആരംഭിച്ചു എന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾ സ്വയം കീകൾ സജ്ജമാക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് 1 ൽ നിന്ന് ആരംഭിക്കാം. എന്നാൽ ഇത് ചെയ്യാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നില്ല, കാരണം ഓട്ടോമാറ്റിക് നമ്പറിംഗ് 0 മുതൽ ആരംഭിക്കുന്നു.
അറേയുടെ ആദ്യ ഘടകം അച്ചടിക്കുന്നു:
ചതുര ബ്രാക്കറ്റിൽ കീ കാണണോ? ഈ കോഡ് "പ്ലാനുകൾ" എന്ന മൂല്യം ഔട്ട്പുട്ട് ചെയ്യും.
ഇഷ്‌ടാനുസൃത അറേ കീകൾ
നിങ്ങൾക്ക് സ്വന്തമായി കീകൾ സൃഷ്ടിക്കാനും കഴിയും. ഒരു PHP അസോസിയേറ്റീവ് അറേയുടെ ഒരു ഉദാഹരണം ഇതാ:
$web_site = array('Name' => 'OSTraining', 'URL' => 'http://ostraining.com', 'ഉദ്ദേശ്യം' => 'വിദ്യാഭ്യാസം');
ഇപ്പോൾ നിങ്ങൾക്ക് ഇതുപോലുള്ള എന്തെങ്കിലും ചെയ്യാൻ കഴിയും:
- പേര്:
- URL:
- ഉദ്ദേശം:
അതിൻ്റെ ഫലമായി നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ലഭിക്കും:
- പേര്: OStraining;
- URL: http://ostraining.com;
- ഉദ്ദേശ്യം: വിദ്യാഭ്യാസം.
ഇഷ്‌ടാനുസൃത കീകൾ ഉപയോഗിക്കുന്നത് നിങ്ങൾ എന്താണ് ഔട്ട്പുട്ട് ചെയ്യുന്നതെന്ന് നിർവചിക്കുന്നത് എളുപ്പമാക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, ഔട്ട്പുട്ട് PHP അറേയുടെ കീ നോക്കുക.
സൈക്കിളുകൾ
ഒരു അറേയിൽ എത്ര ഘടകങ്ങൾ ഉണ്ടെന്നോ അതിൽ ഏതൊക്കെ കീകൾ ഉണ്ടെന്നോ നിങ്ങൾക്ക് അറിയില്ലെങ്കിൽ എന്തുചെയ്യും? PHP-യിൽ, ഒരു foreach loop ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് ഇതാ:
-
$value) (എക്കോ '
- ’ . $കീ. ':'. $മൂല്യം. ' ’; } ?>
ഈ കോഡ് ചെയ്യുന്നത് ഇതാ:
- ഓരോ അറേ എലമെൻ്റിനും ഒരു $കീ വേരിയബിൾ നൽകിയിട്ടുണ്ട്, അതിൻ്റെ മൂല്യം മൂലകത്തിൻ്റെ കീയ്ക്ക് തുല്യമാണ്. മൂലകത്തിൻ്റെ മൂല്യത്തിന് തുല്യമായ ഒരു $value വേരിയബിളും. എല്ലാ ഘടകങ്ങളും പ്രോസസ്സ് ചെയ്യപ്പെടുന്നതുവരെ നമുക്ക് PHP അറേ അടുക്കുന്നു;
- മുകളിൽ ഞാൻ സ്വമേധയാ സൃഷ്‌ടിച്ച അതേ ബുള്ളറ്റ് ലിസ്റ്റ് ഈ കോഡ് സൃഷ്‌ടിക്കും.
മൾട്ടിഡൈമൻഷണൽ അറേകൾ
ഒരു PHP മൾട്ടിഡൈമൻഷണൽ അറേയിൽ, അതിൻ്റെ എല്ലാ ഘടകങ്ങളും അറേകളാണ്. ഉദാഹരണത്തിന്:
$staff = array(0 => array(['Name'] => 'Topher', ['Position'] => 'നിൽക്കുകയോ ഇരിക്കുകയോ, കിടക്കാതിരിക്കുമ്പോൾ'), 1 => array(['Name'] => 'സ്റ്റീവ്', ['സ്ഥാനം'] => 'എഴുത്തുകാരൻ'));
ഞങ്ങൾക്ക് നിരവധി "ആളുകൾ" ഉള്ള ഒരു അറേ $സ്റ്റാഫ് ഉണ്ട്. അവ ഓരോന്നും "ആവർത്തിച്ച്" ചെയ്യാൻ നമുക്ക് നിരവധി ഫോർച്ച് ലൂപ്പുകൾ സൃഷ്ടിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്:
foreach($കീ ആയി $സ്റ്റാഫ് => $person) (എക്കോ '
- '; foreach($person as $attribute => $value) (എക്കോ '
- ’ . $ആട്രിബ്യൂട്ട്. ':' . $മൂല്യം. ' '; ) എക്കോ '
മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഞാൻ ഓരോ വ്യക്തിയിലൂടെയും ഓരോ വ്യക്തിയിലൂടെയും അവരുടെ ഡാറ്റയിലൂടെ ലൂപ്പ് ചെയ്യുകയും അത് ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്തു. വേരിയബിളുകളുടെ മൂല്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നതിന് ഞാൻ അറേ എലമെൻ്റുകൾക്ക് പേരിട്ടു.
സംഗ്രഹിക്കുന്നു
WordPress-ൽ പ്രവർത്തിക്കുമ്പോൾ, ഞങ്ങൾ പലപ്പോഴും WP_Query ഉപയോഗിച്ച് ഡാറ്റാബേസ് അന്വേഷണങ്ങൾ പ്രവർത്തിപ്പിക്കുകയും ഒരു PHP ദ്വിമാന "പോസ്റ്റുകൾ" ഡാറ്റ അറേ നേടുകയും ചെയ്യുന്നു. ഇത് ചെയ്യുന്നതിന്, ഈ എൻട്രികൾ പ്രോസസ്സ് ചെയ്യുന്നതിനും ഔട്ട്പുട്ട് ചെയ്യുന്നതിനും നിങ്ങൾക്ക് foreach ഉപയോഗിക്കാം.
അപ്പുറത്തേക്ക് പോകുന്നു
അറേകൾ അടുക്കാനും സംയോജിപ്പിക്കാനും താരതമ്യം ചെയ്യാനും സംഗ്രഹിക്കാനും മൂലകങ്ങളുടെ ക്രമം മാറ്റാനും കഴിയും. ഞാൻ നിങ്ങളെ വളരെ ശുപാർശ ചെയ്യുന്നു ഔദ്യോഗിക ഡോക്യുമെൻ്റേഷൻ വായിക്കുക. മിക്ക അറേ ഫംഗ്‌ഷനുകൾക്കും വ്യക്തമായ പേരുകൾ ഉള്ളതിനാൽ അവ എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് മനസിലാക്കാൻ കഴിയും.
ബോണസ് സവിശേഷതകൾ
അറേകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്തുചെയ്യാനാകുമെന്നതിൻ്റെ ചില ഉദാഹരണങ്ങൾ ഇതാ:
അറേയിൽ എത്ര ഘടകങ്ങൾ ഉണ്ടെന്ന് ഈ കോഡ് കണക്കാക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഔട്ട്പുട്ട് ചെയ്യാം " നിങ്ങളുടെ തിരയൽ മാനദണ്ഡവുമായി പൊരുത്തപ്പെടുന്ന 14 ഇനങ്ങൾ കണ്ടെത്തി» ( പ്രമാണീകരണം).
അതിനാൽ, ഞങ്ങൾക്ക് $arr എന്ന ഒരു അറേ ഉണ്ട്, ഈ അറേയുടെ ആദ്യ ഘടകം നമുക്ക് ലഭിക്കേണ്ടതുണ്ട്.
നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയില്ല:
$ആദ്യം = $arr;
സൂചിക 0-ലെ മൂലകം നിർവചിച്ചേക്കില്ല. ഉദാഹരണത്തിന്, അറേ അസ്സോസിയേറ്റീവ് ആണെങ്കിൽ, അല്ലെങ്കിൽ ഞങ്ങൾ അൺസെറ്റ് ചെയ്താൽ($arr) .
രീതി 1
$ആദ്യം = റീസെറ്റ് ($arr);റീസെറ്റ് ഉപയോഗിച്ച് നമുക്ക് ആദ്യ ഘടകം ലഭിക്കും, എന്നിരുന്നാലും ഒരു പാർശ്വഫലമുണ്ട്: അറേ പോയിൻ്ററും ആദ്യ ഘടകത്തിലേക്ക് പുനഃസജ്ജമാക്കുന്നു. തത്വത്തിൽ ഈ പ്രവർത്തനം പോയിൻ്റർ പുനഃസജ്ജമാക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണെങ്കിലും. റീസെറ്റ്() ഫംഗ്‌ഷനുള്ള ഡോക്യുമെൻ്റേഷൻ.
അറേ ശൂന്യമാണെങ്കിൽ റീസെറ്റ്() എന്നത് തെറ്റായി നൽകുമെന്നും അറേ ശൂന്യമല്ലെങ്കിലും ആദ്യ ഘടകമായി തെറ്റ് അടങ്ങിയിരിക്കുന്ന സാഹചര്യത്തിൽ നിന്ന് ഈ ഫലം വേർതിരിച്ചറിയാൻ കഴിയില്ലെന്നും ശ്രദ്ധിക്കുക.
$a = അറേ(); $b = അറേ (തെറ്റ്, ശരി, ശരി); var_dump(reset($a) === reset($b)); //bool (ശരി)
രീതി 2
നിങ്ങൾക്ക് array_shift ഫംഗ്ഷൻ ഉപയോഗിക്കാം - ഇത് ആദ്യ ഘടകം വീണ്ടെടുക്കുകയും അതേ സമയം പാസായ അറേയിൽ നിന്ന് അത് നീക്കം ചെയ്യുകയും ചെയ്യുന്നു. Array_shift() ഡോക്യുമെൻ്റേഷൻ.
$ആദ്യം = array_shift($arr);
രീതി 3
ഈ ആവശ്യങ്ങൾക്കായി നിങ്ങളുടെ സ്വന്തം ഫംഗ്ഷൻ എഴുതുക:
ഫംഗ്ഷൻ array_first($array, $default = null) ( foreach ($array as $item) ($item തിരികെ നൽകുക; ) $default തിരികെ നൽകുക; )
ഒറിജിനൽ അറേയെ ഇത് മാറ്റില്ല എന്നതാണ് നേട്ടം. നിങ്ങൾക്ക് ഒരു $default പാരാമീറ്ററും കൈമാറാൻ കഴിയും, അറേ ശൂന്യമാണെങ്കിൽ അത് ഡിഫോൾട്ട് മൂല്യമായി ഉപയോഗിക്കും.
വഴിയിൽ, Laravel ചട്ടക്കൂടിൽ ഈ ഫംഗ്ഷൻ ഇതിനകം നിർവചിക്കപ്പെട്ടിട്ടുണ്ട് കൂടാതെ നിങ്ങൾക്ക് ഒരു നിബന്ധന പാസാക്കാൻ കഴിയുന്ന ഒരു കോൾബാക്ക് വ്യക്തമാക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് 10-ൽ കൂടുതലുള്ള ആദ്യ മൂലകമോ സംഖ്യയല്ലാത്ത ആദ്യ മൂലകമോ എടുക്കാം.
കൂടുതൽ വിപുലമായ പ്രവർത്തനത്തിനുള്ള കോഡ് ഇതാ:
ഫംഗ്ഷൻ array_first($array, callable $callback = null, $default = null) if (is_null($callback)) ((ശൂന്യമാണെങ്കിൽ($array)) (ക്ലോഷറിൻ്റെ $default instance ? $default() : $default; ) foreach ($array as $item) ($array as $item; ) ) foreach ($array as $key => $value) ((call_user_func($callback, $value, $key)) ($value തിരികെ നൽകുക; ) ) അടച്ചുപൂട്ടലിൻ്റെ $default instance തിരികെ നൽകണോ ? $default() : $default; )
ഉദാഹരണത്തിന്, ഇത് ഇതുപോലെ ഉപയോഗിക്കാം:
$അറേ = ; $first = array_first($array, function ($value, $key) ($value>= 150; ))); പ്രതിധ്വനി $ ആദ്യം; // 200
രീതി 4
ഒരു അറേയുടെ ആദ്യ ഘടകം ലഭിക്കുന്നതിന് നിലവിലെ() ഫംഗ്ഷൻ ഉപയോഗപ്രദമാണ്.
ഉപയോഗ ഉദാഹരണം:
$ ട്രാൻസ്പോർട്ട് = അറേ ("കാൽ", "ബൈക്ക്", "കാർ", "വിമാനം"); $ മോഡ് = കറൻ്റ് ($ ട്രാൻസ്പോർട്ട്); // $ മോഡ് = "പാദം";
കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഇൻ്റേണൽ അറേ പോയിൻ്റർ സ്ഥിതി ചെയ്യുന്ന മൂലകം തിരികെ നൽകാൻ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. മിക്ക കേസുകളിലും പോയിൻ്റർ ആദ്യ ഘടകത്തിലേക്കാണ്, എന്നിരുന്നാലും തിരികെ ലഭിക്കുന്ന ആദ്യ ഘടകമായിരിക്കാത്ത സാഹചര്യങ്ങളുണ്ട്.
$ ട്രാൻസ്പോർട്ട് = അറേ ("കാൽ", "ബൈക്ക്", "കാർ", "വിമാനം"); അടുത്തത് ($ ഗതാഗതം); // പോയിൻ്റർ മുന്നോട്ട് നീക്കുക (http://php.net/manual/ru/function.next.php) $ മോഡ് = കറൻ്റ് ($ ട്രാൻസ്പോർട്ട്); // $മോഡ് = "ബൈക്ക്"; - അതായത് അറേയുടെ രണ്ടാമത്തെ ഘടകം ഇതിനകം തിരിച്ചെത്തി.
ഈ രീതിക്ക് കമൻ്റേറ്റർ അലക്സി ബെർലിൻസ്കിക്ക് നന്ദി.
ആദ്യ ഘടകം ലഭിക്കുന്നതിനുള്ള വഴികൾ നിങ്ങൾക്ക് ഇപ്പോഴും അറിയാമെങ്കിൽ, അഭിപ്രായങ്ങളിൽ എഴുതുക.
ഈ ലേഖനം സഹായകമായിരുന്നോ?
