किसी सरणी को हटाए बिना अंतिम तत्व प्राप्त करने का सबसे अच्छा तरीका क्या है?

Question

ठीक है,

मैं सभी के बारे में जानता हूं array_pop(), लेकिन यह अंतिम तत्व को हटा देता है। किसी सरणी को हटाए बिना अंतिम तत्व प्राप्त करने का सबसे अच्छा तरीका क्या है?

संपादित करें: यहाँ एक बोनस है:

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');

या और भी

$array = array('a', 'b', 'c', 'd');
unset($array[2]);
echo $array[sizeof($array) - 1]; // Output: PHP Notice:  Undefined offset:  2 in - on line 4

Comments

मानो या न कि इसे popping और इसे वापस रखना सबसे तेज़ तरीकों में से एक है जिसे मैंने ऐसा करने के लिए बेंचमार्क किया था। $ वैल = $ सरणी [] = array_pop ($ सरणी); इको $ वैल;

— user2782001

इस सवाल के कई विकल्प थे। खुद को चुनने में मदद करने के लिए, मैंने सबसे उल्लेखनीय / विशिष्ट विकल्पों में से कुछ की तुलना की और परिणामों को एक अलग उत्तर के रूप में साझा किया । (: @ user2782001 ने उपरोक्त टिप्पणी में अब तक मेरा पसंदीदा सुझाव दिया है। :) योगदान देने के लिए सभी को धन्यवाद!

— पॉल वैन लीउवेन

@TheodoreRSmith जब पीएचपी 7.3 जारी किया गया है आप (बनाने पर विचार कर सकता है इस सुझाव से Quasimodo के क्लोन 'स्वीकार किए जाते हैं जवाब' (आपके विचार के लिए) ...

— पॉल वैन ल्युवेन

Answer 1

इस धागे में कई उत्तर हमें कई अलग-अलग विकल्पों के साथ पेश करते हैं। उनसे चुनने में सक्षम होने के लिए मुझे उनके व्यवहार और प्रदर्शन को समझने की आवश्यकता थी। इस उत्तर में, मैं अपने निष्कर्षों को आपके साथ साझा करूंगा, PHP संस्करणों के खिलाफ बेंचमार्क किया जाएगा 5.6.38, 7.2.10और 7.3.0RC1( 13 दिसंबर 2018 को अपेक्षित )।

<<option code>>मेरे द्वारा परीक्षण किए जाने वाले विकल्प हैं:

• विकल्प 1। $x = array_values(array_slice($array, -1))[0];( जैसा कि rolacja द्वारा सुझाया गया है)
• विकल्प 2। $x = array_slice($array, -1)[0];( स्टाउटी द्वारा सुझाया गया)
• विकल्प ।3। $x = array_pop((array_slice($array, -1)));( जैसा कि rolacja द्वारा सुझाया गया है)
• विकल्प ।4। $x = array_pop((array_slice($array, -1, 1)));( जैसा Westy92 द्वारा सुझाया गया है)
• विकल्प ।5। $x = end($array); reset($array);( इज़्नोगूड द्वारा सुझाए गए)
• विकल्प ।6। $x = end((array_values($array)));( TecBrat द्वारा सुझाए गए अनुसार )
• विकल्प ।7। $x = $array[count($array)-1];( जैसा कि मिर्को पगलिया ने सुझाया है)
• विकल्प ।8। $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( जैसा कि थ्रू ने सुझाया है )
• विकल्प ।9। $x = $array[] = array_pop($array);( user2782001 द्वारा सुझाया गया)
• विकल्प 10. $x = $array[array_key_last($array)]; ( जैसा कि क्वासिमोडो क्लोन द्वारा सुझाया गया है; PHP 7.3 के अनुसार उपलब्ध है)

(उल्लिखित कार्य: array_key_last , array_keys , array_pop , array_slice , array_values , count , end , रीसेट )

परीक्षण निविष्टियाँ <<input code>>:

• नल =$array = null;
• खाली =$array = [];
• last_null =$array = ["a","b","c",null];
• auto_idx =$array = ["a","b","c","d"];
• फेरबदल =$array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
• 100 =$array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
• 100000 =$array = []; for($i=0;$i<100000;$i++) { $array[] = $i; }

परीक्षण के लिए 5.6.38, मैं 7.2.10और 7.3.0RC1 PHP डॉकटर कंटेनरों का उपयोग करूँगा जैसे:

sudo docker run -it --rm php:5.6.38-cli-stretch php -r '<<<CODE HERE>>>'

उपरोक्त सूचीबद्ध <<option code>>s और <<input code>>s का प्रत्येक संयोजन PHP के सभी संस्करणों पर चलाया जाएगा। प्रत्येक परीक्षण चलाने के लिए निम्नलिखित कोड स्निपेट का उपयोग किया जाता है:

<<input code>>  error_reporting(E_ALL);  <<option code>>  error_reporting(0); $before=microtime(TRUE); for($i=0;$i<100;$i++){echo ".";for($j=0;$j<100;$j++){  <<option code>>  }}; $after=microtime(TRUE); echo "\n"; var_dump($x); echo round(($after-$before)/(100*100)*1000*1000*1000);

प्रत्येक रन के लिए यह परीक्षण इनपुट के अंतिम पुनर्प्राप्त अंतिम मान को var_dump करेगा और femtoseconds में एक पुनरावृत्ति की औसत अवधि प्रिंट करेगा (एक सेकंड का 0.000000000000001 वां )।

परिणाम इस प्रकार हैं:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            T  E  S  T     I  N  P  U  T     -     5  .  6  .  3  8                            ||                             T  E  S  T     I  N  P  U  T     -     7  .  2  .  1  0                           ||                             T  E  S  T     I  N  P  U  T     -     7  .  3  .  0  R  C  1                     ||
||                                                                      ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||
||============================OPTIONS - ERRORS==========================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||
||  2.  $x = array_slice($array, -1)[0];                                ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  5.  $x = end($array); reset($array);                                ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||       W4 + W5 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||
||  6.  $x = end((array_values($array)));                               ||       W2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  7.  $x = $array[count($array)-1];                                   ||             - |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||            W6 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||
||  9.  $x = $array[] = array_pop($array);                              ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||
|| 10.  $x = $array[array_key_last($array)];                            ||            F1 |            F1 |            F1 |            F1 |            F1 |            F1 |            F1 ||            F2 |            F2 |            F2 |            F2 |            F2 |            F2 |            F2 ||            W8 |            N4 |            F2 |            F2 |            F2 |            F2 |            F2 ||
||========================OPTIONS - VALUE RETRIEVED=====================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  2.  $x = array_slice($array, -1)[0];                                ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  5.  $x = end($array); reset($array);                                ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  6.  $x = end((array_values($array)));                               ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  7.  $x = $array[count($array)-1];                                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  9.  $x = $array[] = array_pop($array);                              ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||
||=================OPTIONS - FEMTOSECONDS PER ITERATION=================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||           803 |           466 |           390 |           384 |           373 |           764 |     1.046.642 ||           691 |           252 |           101 |           128 |            93 |           170 |        89.028 ||           695 |           235 |            90 |            97 |            95 |           188 |        87.991 ||
||  2.  $x = array_slice($array, -1)[0];                                ||           414 |           349 |           252 |           248 |           246 |           604 |     1.038.074 ||           373 |           249 |            85 |            91 |            90 |           164 |        90.750 ||           367 |           224 |            78 |            85 |            80 |           155 |        86.141 ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||           724 |           228 |           323 |           318 |           350 |           673 |     1.042.263 ||           988 |           285 |           309 |           317 |           331 |           401 |        88.363 ||           877 |           266 |           298 |           300 |           326 |           403 |        87.279 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||           734 |           266 |           358 |           356 |           349 |           699 |     1.050.101 ||           887 |           288 |           316 |           322 |           314 |           408 |        88.402 ||           935 |           268 |           335 |           315 |           313 |           403 |        86.445 ||
||  5.  $x = end($array); reset($array);                                ||           715 |           186 |           185 |           180 |           176 |           185 |           172 ||           674 |            73 |            69 |            70 |            66 |            65 |            70 ||           693 |            65 |            85 |            74 |            68 |            70 |            69 ||
||  6.  $x = end((array_values($array)));                               ||           877 |           205 |           320 |           337 |           304 |         2.901 |     7.921.860 ||           948 |           300 |           336 |           308 |           309 |           509 |    29.696.951 ||           946 |           262 |           301 |           309 |           302 |           499 |    29.234.928 ||
||  7.  $x = $array[count($array)-1];                                   ||           123 |           300 |           137 |           139 |           143 |           140 |           144 ||           312 |           218 |            48 |            53 |            45 |            47 |            51 ||           296 |           217 |            46 |            44 |            53 |            53 |            55 ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||           494 |           593 |           418 |           435 |           399 |         3.873 |    12.199.450 ||           665 |           407 |           103 |           109 |           114 |           431 |    30.053.730 ||           647 |           445 |            91 |            95 |            96 |           419 |    30.718.586 ||
||  9.  $x = $array[] = array_pop($array);                              ||           186 |           178 |           175 |           188 |           180 |           181 |           186 ||            83 |            78 |            75 |            71 |            74 |            69 |            83 ||            71 |            64 |            70 |            64 |            68 |            69 |            81 ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           370 |           223 |            49 |            52 |            61 |            57 |            52 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/ 

उपर्युक्त एफ अटल, डब्ल्यू अर्निंग और एन ओटिस कोड इस प्रकार हैं:

F1 = Fatal error: Call to undefined function array_key_last() in Command line code on line 1
F2 = Fatal error: Uncaught Error: Call to undefined function array_key_last() in Command line code:1
W1 = Warning: array_slice() expects parameter 1 to be array, null given in Command line code on line 1
W2 = Warning: array_values() expects parameter 1 to be array, null given in Command line code on line 1
W3 = Warning: array_pop() expects parameter 1 to be array, null given in Command line code on line 1
W4 = Warning: end() expects parameter 1 to be array, null given in Command line code on line 1
W5 = Warning: reset() expects parameter 1 to be array, null given in Command line code on line 1
W6 = Warning: array_keys() expects parameter 1 to be array, null given in Command line code on line 1
W7 = Warning: count(): Parameter must be an array or an object that implements Countable in Command line code on line 1
W8 = Warning: array_key_last() expects parameter 1 to be array, null given in Command line code on line 1
N1 = Notice: Undefined offset: 0 in Command line code on line 1
N2 = Notice: Only variables should be passed by reference in Command line code on line 1
N3 = Notice: Undefined offset: -1 in Command line code on line 1
N4 = Notice: Undefined index:  in Command line code on line 1

इस आउटपुट के आधार पर मैं निम्नलिखित निष्कर्ष निकालता हूं:

• PHP के नए संस्करण इन विकल्पों के अपवाद के साथ बेहतर प्रदर्शन करते हैं जो काफी धीमी हो गई:
  • विकल्प ।6। $x = end((array_values($array)));
  • विकल्प ।8। $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• ये विकल्प बहुत बड़े सरणियों के लिए सर्वोत्तम हैं:
  • विकल्प ।5। $x = end($array); reset($array);
  • विकल्प ।7। $x = $array[count($array)-1];
  • विकल्प ।9। $x = $array[] = array_pop($array);
  • विकल्प 10. $x = $array[array_key_last($array)]; (PHP 7.3 के बाद से)
• इन विकल्पों का उपयोग केवल ऑटो-इंडेक्सेड सरणियों के लिए किया जाना चाहिए :
  • विकल्प ।7। $x = $array[count($array)-1];(उपयोग के कारणcount)
  • विकल्प ।9। $x = $array[] = array_pop($array);(मूल कुंजी खोने के कारण असाइन करने का मूल्य)
• यह विकल्प सरणी के आंतरिक पॉइंटर को संरक्षित नहीं करता है
  • विकल्प ।5। $x = end($array); reset($array);
• यह विकल्प विकल्प को संशोधित करने का एक प्रयास है ।5। सरणी के आंतरिक सूचक को संरक्षित करने के लिए (लेकिन दुख की बात है कि यह बहुत बड़े सरणियों के लिए अच्छी तरह से पैमाने पर नहीं है)
  • विकल्प ।6। $x = end((array_values($array)));
• array_key_lastलगता है कि नया फ़ंक्शन इस लेखन के समय आरसी होने के अपवाद के साथ उपरोक्त उल्लिखित सीमाओं में से कोई भी नहीं है (इसलिए आरसी का उपयोग करें या इसे जारी करने का इंतजार करें दिसंबर 2018):
  • विकल्प 10. $x = $array[array_key_last($array)]; (PHP 7.3 के बाद से)

इस बात पर निर्भर करता है कि ऐरे को स्टैक के रूप में इस्तेमाल किया जा रहा है या कतार के रूप में आप विकल्प 9 पर बदलाव कर सकते हैं।

Comments

यदि आपको कोई विशेष विकल्प याद आ रहा है तो आप उपरोक्त कोड स्निपेट को एक साथ कॉपी करके चिपका सकते हैं, पहले से परीक्षण किए गए विकल्प के मुकाबले। इस सूची में एक विकल्प जोड़ने के लिए तुलनीय प्रदर्शन परिणामों के लिए सभी संयोजनों को पुनः प्राप्त किया जाएगा। यदि आपके पास एक विशेष विकल्प है जो आपको लगता है कि जोड़ा जाना चाहिए, तो कृपया एक टिप्पणी छोड़ दें, मैं इसे जोड़ने का इरादा रखता हूं (हालांकि इसमें कुछ समय लग सकता है)।

— पॉल वैन लीउवेन

बहुत बढ़िया जवाब, एक टिप्पणी हालांकि: साहचर्य सरणियों विकल्प 9 के लिए भी इस्तेमाल नहीं किया जा सकता है, क्योंकि हम पिछले प्रमुख नाम के बजाय एक ऑटो-इंडेक्स किए गए कुंजी को वापस असाइन कर रहे हैं।

— ग्रास डबल

अच्छा सारांश! कृपया नए PHP 7.3 का उपयोग करके मेरा उत्तर जोड़ें । $array[array_key_last($array)];अपने बेंचमार्क पर कार्य करें। और कृपया मुझे कुछ अधिसूचना दें जब किया मैं तुलना में प्रदर्शन के परिणाम देखना पसंद करता हूं।

— क्वासिमोडो का क्लोन

@sz यह मुख्य रूप से बहुत ही हठ और धैर्य के साथ तैयार किया गया था, लेकिन सामान्य चयन और सब-लाइम एडिटर के बहु-पंक्ति संपादन कार्यों ने मदद की। इसे पुनर्जीवित करने में लगभग एक दिन लग गया, इसलिए अगर मुझे इसे फिर से करने की आवश्यकता होती है, तो मैं शायद कुछ लिखूंगा जो सभी 210 डॉकरों के आउटपुट को स्वचालित रूप से एक तालिका में परिवर्तित करता है :-)

— पॉल वैन लीउवेन

@ क्वासिमोडोस-क्लोन I ने नवीनतम रिलीज़ किए गए PHP 5, 7 और आपके RC पर आधारित संपूर्ण तालिका को पुनः प्राप्त किया। मुझे लगता है कि हम इसे दिसंबर में फिर से तब उत्पन्न करना चाहेंगे जब यह वास्तव में रिलीज़ हो। इस नए फंक्शन को सबके ध्यान में लाने के लिए धन्यवाद।

— पॉल वैन लीउवेन 20

Answer 2

प्रयत्न

$myLastElement = end($yourArray);

इसे रीसेट करने के लिए (धन्यवाद @hopeseekr):

 reset($yourArray);

मैनुअल से लिंक करें

@ डेविड मर्डोक ने कहा: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). E_STRICT पर यह चेतावनी उत्पन्न करता है

Strict Standards: Only variables should be passed by reference

धन्यवाद o_O टिंच और हर कोई!

Comments

उपयोग करें $myLastElement = end(array_values($yourArray));और अब आपको कॉल करने की आवश्यकता नहीं है reset()।

— डेविड मर्डोक

@DavidMurdoch शायद, लेकिन यह निश्चित रूप से RAM और CPU को मंथन करता है, जो ऐरे वैल्यूज़ के लिए अस्थायी व्यूह रचता है ...

— Theodore R. Smith

यदि आपका सर्वर बहुत अधिक रैम का उपभोग कर रहा है, ताकि एक साधारण अतिरिक्त फ़ंक्शन कॉल करना एक सौदा ब्रेकर है, तो मैं आपको सुझाव देता हूं कि आप अपने सर्वर के कॉन्फ़िगरेशन और संसाधनों की फिर से जांच करें।

— क्रिस बेकर

end(array_values())E_STRICT देगा: "केवल चर को संदर्भ द्वारा पारित किया जाना चाहिए"

— kolypto

सख्त चेतावनी से बचने के लिए अतिरिक्त कोष्ठक जोड़ें:end((array_values($yourArray)))

— डैनियल डब्ल्यू।

Answer 3

छोटा एवं सुन्दर।

मैं त्रुटि संदेश को दूर करने और वन-लाइनर फॉर्म और कुशल प्रदर्शन को संरक्षित करने के लिए समाधान के साथ आया था:

$lastEl = array_values(array_slice($array, -1))[0];

- पिछले समाधान

$lastEl = array_pop((array_slice($array, -1)));

नोट: अतिरिक्त कोष्ठक से बचने के लिए आवश्यक हैं PHP Strict standards: Only variables should be passed by reference।

Comments

ठीक ५ साल, ६ महीने और २ दिन के बाद, आपने अधिक बेहतर उत्तर प्रस्तुत किया है !! धन्यवाद! और ढेर अतिप्रवाह धन्यवाद !!

— थियोडोर आर। स्मिथ

अभिवादन का उत्तर दें, लेकिन अतिरिक्त कोष्ठकों को जोड़ने से थोड़ा हैकैस्क महसूस होता है। इसके अलावा phpStorm इसे एक त्रुटि के रूप में चिह्नित करेगा। अतिरिक्त कोष्ठक जोड़ने के लिए अतिरिक्त जानकारी ( phpsadness.com/sad/51 )। त्रुटि को दूर करने के लिए, आप इसे '2-लाइनर' बना सकते हैं: $array = array_slice($array, -1); $lastEl = array_pop($array);व्यक्तिगत रूप से मुझे लगता है कि यह बेहतर है (बिना पार्सर 'बग')

— मौरिस

आप इस तरह से डेरेफ्रेंसिंग का उपयोग कर सकते हैं: array_slice ($ array, -1) [0]

— Vikash

यदि आपके पास सरणी में सूचकांक के रूप में तार नहीं हैं

— rolacja

PHP के नोटिस से बचने के लिए इस उत्तर को अभी भी कम से कम दो चेक की आवश्यकता है। 1। जांचें कि क्या array_size() > 1 2. जांचें कि क्या सरणी वास्तव में एक सरणी है। मैं अभी भी @Iznogood द्वारा उत्तर के लिए छड़ी करता हूं क्योंकि PHP का इन-बिल्ट end()फ़ंक्शन पहले से ही सभी कड़ी मेहनत को अधिक कुशल तरीके से करता है।

— Ema4rl

Answer 4

इसमें गलत क्या है array_slice($array, -1)? (मैनुअल देखें: http://us1.php.net/array_slice )

array_slice()एक सरणी देता है। शायद नहीं जो आप ढूंढ रहे हैं। आप तत्व चाहते हैं।

Comments

array_slice($array, -1)[0]तत्व प्राप्त करने के लिए उपयोग करें ।

— पैंग

यह उत्तर है। "अंत" सरणी के आंतरिक पॉइंटर को बदलना? मुसीबत के लिए पूछ रहा है, और पढ़ने के लिए बहुत मुश्किल है!

— जेरार्ड ओनेल

इस दृष्टिकोण से प्यार करें, हालाँकि @Pang बताते हैं, यह पूर्ण नहीं है। reset(array_slice($array, -1))एक और दृष्टिकोण है (जो array_slice()एक एकल-एलीमेंट सरणी की तुलना में "छोटा" रिटर्न करने पर कोई त्रुटि पैदा नहीं करेगा )

— rinogo

सबसे अच्छा तरीका जैसा कि आप सीधे तत्व को संशोधित कर सकते हैं:array_slice($array, -1)[0] = "";

— हैलेक्स

Answer 5

पास-दर-संदर्भ त्रुटियों से बचने का एक तरीका (जैसे। "अंत (array_values ​​($ foo))") call_user_func या call_user_func_array का उपयोग करना है:

// PHP Fatal error: Only variables can be passed by reference
// No output (500 server error)
var_dump(end(array(1, 2, 3)));

// No errors, but modifies the array's internal pointer
// Outputs "int(3)"
var_dump(call_user_func('end', array(1, 2, 3)));

// PHP Strict standards:  Only variables should be passed by reference
// Outputs "int(3)"
var_dump(end(array_values(array(1, 2, 3))));

// No errors, doesn't change the array
// Outputs "int(3)"
var_dump(call_user_func('end', array_values(array(1, 2, 3))));

Comments

महान दृष्टिकोण! (मानक डालें 'यह यहाँ स्वीकृत उत्तर होना चाहिए)

— टाइपो

या बस एक अतिरिक्त पैरेन्थेसिस जोड़ें। कम और मीठा:end((array_values($yourArray)))

— Dzhuneyt

अतिरिक्त कोष्ठक चाल PHP में एक बग पर निर्भर करती है, और यह दृष्टिकोण अब PHP के बाद के संस्करणों (या कम से कम, PHP 7 में नहीं) में काम करता है।

— मैट ब्राउन

और call_user_funcट्रिक PHP 7 में भी काम नहीं करता है। मुझे लगता है कि आप एक अस्थायी चर बनाने के साथ फंस गए हैं।

— मैट ब्राउन

Answer 6

यदि आप आंतरिक पॉइंटर को संशोधित करने के बारे में परवाह नहीं करते हैं (दोनों अनुक्रमित और साहचर्य सरणियों का समर्थन करता है):

// false if empty array
$last = end($array);

// null if empty array
$last = !empty($array) ? end($array) : null;

यदि आप एक उपयोगिता फ़ंक्शन चाहते हैं जो आंतरिक पॉइंटर को संशोधित नहीं करता है (क्योंकि सरणी मान द्वारा पारित किया गया है, और फ़ंक्शन इसकी एक प्रति पर काम करता है):

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    return end($array);
}

ध्यान दें कि PHP "ऑन-द-फ्लाई" प्रतियां बनाता है, अर्थात केवल जब वास्तव में जरूरत होती है। end()खुद सरणी है, तो आंतरिक रूप से सरणी की एक प्रति उत्पन्न होता है संशोधित करता है।

इस प्रकार, निम्नलिखित विकल्प वास्तव में तेज है क्योंकि आंतरिक रूप से यह सरणी की नकल नहीं करता है, यह सिर्फ एक टुकड़ा बनाता है:

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    foreach (array_slice($array, -1) as $value) {
        return $value;
    }
}

यह "foreach / return" कुशलता से पहली (और यहाँ एकल) आइटम प्राप्त करने के लिए एक ट्वीक है।

अंत में, सबसे तेज़ विकल्प लेकिन केवल अनुक्रमित सरणियों के लिए:

$last = !empty($array) ? $array[count($array)-1] : null;

---

अभिलेख के लिए, यहाँ मेरा पहला उत्तर है , सरणी के पहले तत्व के लिए।

Comments

आप एक array_lastफ़ंक्शन के लिए 2 वैकल्पिक कार्यान्वयन प्रदान करते हैं । पहली के लिए आप कहते हैं कि $arrayनकल की है और दूसरी के लिए कि यह नकल नहीं है। कहां अंतर है / क्यों इसे पहले कार्यान्वयन में कॉपी किया गया है और दूसरे में नहीं?

— पॉल वैन लीउवेन

@PaulvanLeeuwen मुझे समझ में आया कि आप भ्रमित क्यों हुए। मैंने उत्तर को स्पष्ट करने की कोशिश की , क्या यह बेहतर है?

— ग्रास डबल

Answer 7

निष्कलंक: यह काम नहीं करेगा?

<?php
$last_element=end(array_values($array));
?>

चूंकि array_values ​​द्वारा लौटाया गया सरणी क्षणभंगुर है, अगर कोई सूचक रीसेट है तो कोई परवाह नहीं करता है।

और अगर आपको इसके साथ जाने की कुंजी की आवश्यकता है तो मुझे लगता है कि आप क्या करेंगे:

<?php
$last_key=end(array_keys($array));
?>

Answer 8

मुझे स्टैक से निपटने के लिए अक्सर इसकी आवश्यकता होती है, और मैं हमेशा खुद को चकित पाता हूं कि कोई मूल कार्य नहीं है जो किसी भी रूप में सरणी या इसके आंतरिक पॉइंटर को हेरफेर किए बिना करता है।

इसलिए मैं आमतौर पर एक उपयोग फ़ंक्शन के आसपास ले जाता हूं जो साहचर्य सरणियों पर उपयोग करने के लिए सुरक्षित है।

function array_last($array) {
    if (count($array) < 1)
        return null;

    $keys = array_keys($array);
    return $array[$keys[sizeof($keys) - 1]];
}

Comments

अच्छी खबर है, वे इसे एक मूल कार्य बना रहे हैं :-) आप इसे जारी करने की योजना पर नज़र रख सकते हैं: wiki.php.net/todo/php73 (इस लेखन के समय 13 दिसंबर 2018 को अपेक्षित)।

— पॉल वैन लीउवेन

Answer 9

किसी सरणी का अंतिम तत्व प्राप्त करने के लिए:

$lastElement = array_slice($array, -1)[0];

बेंचमार्क

मैंने छोटे और बड़े सरणियों के अंतिम तत्व को हथियाने के लिए 1,000 बार पुनरावृत्त किया, जिसमें क्रमशः 100 और 50,000 तत्व शामिल थे।

Method: $array[count($array)-1];
Small array (s): 0.000319957733154
Large array (s): 0.000526905059814
Note: Fastest!  count() must access an internal length property.
Note: This method only works if the array is naturally-keyed (0, 1, 2, ...).

Method: array_slice($array, -1)[0];
Small array (s): 0.00145292282104
Large array (s): 0.499367952347

Method: array_pop((array_slice($array, -1, 1)));
Small array (s): 0.00162816047668
Large array (s): 0.513121843338

Method: end($array);
Small array (s): 0.0028350353241
Large array (s): 4.81077480316
Note: Slowest...

मैंने PHP संस्करण 5.5.32 का उपयोग किया।

Comments

$ array [array_keys ($ array) [count (array_keys ($ array)) - 1]] का उपयोग करने के बारे में क्या?

— user2782001

hmm..array_keys बहुत खराब पैमाने पर लगता है।

— user2782001

यह वास्तव में आइटम को पॉप करने के लिए बड़े सरणी (0.0002) के लिए तेजी से पागल है और इसे वापस डाल दिया है ... $ val = $ ar [] = $ array_pop ($ ar);

— user2782001

@ Westy92 बेंचमार्क पर आपकी इकाइयाँ गलत लगती हैं। आपके द्वारा दी गई सबसे छोटी संख्या 0.00031 है ... माइक्रोसेकंड जो लगभग 0.3 नैनोसेकंड है। इसका मतलब होगा कि यदि आपके पास एक नया कंप्यूटर है, तो आपके परीक्षण ने एक घड़ी की टिक टिक ली है। मुझे लगता है कि आप या तो मिलीसेकंड या संभवत: सेकंड का मतलब है ।

— cesoid

मान स्पष्ट रूप से परिमाण के कई आदेश गलत हैं। वैसे भी प्रदर्शन पर ध्यान क्यों?

— istepaniuk

Answer 10

अंत () एक सरणी का अंतिम तत्व प्रदान करेगा

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
echo end($array); //output: c

$array1 = array('a', 'b', 'c', 'd');
echo end($array1); //output: d

Comments

यह समाधान काम करता है, लेकिन यह सरणी के आंतरिक पॉइंटर को बदलता है, मुझे नहीं लगता कि यह सही तरीका है।

— UnixAgain

Answer 11

PHP संस्करण 7.3 के रूप में कार्य करता है array_key_firstऔरarray_key_last पेश किया गया है।

चूंकि PHP में सरणियाँ सख्त सरणी प्रकार नहीं हैं, अर्थात निश्चित आकार के फ़ील्ड्स का निश्चित आकार सूचकांक 0 पर शुरू होता है, लेकिन गतिशील रूप से विस्तारित साहचर्य सरणी, अज्ञात कुंजियों के साथ पदों की हैंडलिंग कठिन है और वर्कअराउंड बहुत अच्छा प्रदर्शन नहीं करते हैं। इसके विपरीत वास्तविक सरणियों को बहुत तेजी से सूचक अंकगणितीय के माध्यम से आंतरिक रूप से संबोधित किया जाएगा और अंतिम सूचकांक पहले से ही घोषणा द्वारा संकलन-समय पर जाना जाता है।

कम से कम पहली और आखिरी स्थिति के साथ समस्या का समाधान बिलिन फ़ंक्शन द्वारा किया जाता है जो अब संस्करण 7.3 के बाद से है। यह भी बॉक्स के बाहर सरणी शाब्दिक पर किसी भी चेतावनी के बिना काम करता है :

$first = array_key_first( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );
$last  = array_key_last ( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );

स्पष्ट रूप से अंतिम मूल्य है:

$array[array_key_last($array)];

Comments

इसे सबके ध्यान में लाने के लिए धन्यवाद। उन लोगों के लिए जो इसका उपयोग करने के लिए उत्सुक हैं: कृपया नहीं कि यह इस लेखन के क्षण में आरसी है। यह दिसंबर 2018 को रिलीज होने वाली है।

— पॉल वैन लीउवेन

यह अच्छी खबर है। मैंने अभी अपने उत्तर में एक पॉलीफ़िल / शिम पोस्ट किया है ताकि लोग इस वाक्यविन्यास का तुरंत उपयोग करना शुरू कर सकें।

— मार्क थॉमसन

Answer 12

$lastValue = end(array_values($array))

$ सरणी पॉइंटर्स के लिए कोई संशोधन नहीं किया गया है। इससे बचा जाता है

reset($array)

जो कुछ शर्तों में वांछित नहीं हो सकता है।

Answer 13

मेरे लिए:

$last = $array[count($array) - 1];

सहयोगियों के साथ:

$last =array_values($array)[count($array - 1)]

Comments

कृपया अपने उत्तर के लिए कुछ संदर्भ प्रदान करें।

— शॉन

@ कौन सा संदर्भ? संदर्भ की जरूरत नहीं है। सहयोगी सरणियों के लिए जोड़ा गया कोड।

— मिर्को पगलिया 20

Answer 14

शीर्ष उत्तर बहुत अच्छे हैं, लेकिन जैसा कि @ paul-van-leeuwen और @ quasimodos-clone द्वारा बताया गया है, PHP 7.3 इस समस्या को सीधे हल करने के लिए दो नए कार्यों को प्रस्तुत करेगा - array_key_first () और array_key_last () ।

आप निम्न पॉलीफ़िल (या शिम) फ़ंक्शन के साथ आज इस सिंटैक्स का उपयोग करना शुरू कर सकते हैं।

// Polyfill for array_key_last() available from PHP 7.3
if (!function_exists('array_key_last')) {
  function array_key_last($array) {
    return array_slice(array_keys($array),-1)[0];
  }
}

// Polyfill for array_key_first() available from PHP 7.3
if (!function_exists('array_key_first')) {
  function array_key_first($array) {
    return array_slice(array_keys($array),0)[0];
  }
}

// Usage examples:
$first_element_key   = array_key_first($array);
$first_element_value = $array[array_key_first($array)];

$last_element_key    = array_key_last($array);
$last_element_value  = $array[array_key_last($array)];

कैविएट: इसके लिए PHP 5.4 या अधिक की आवश्यकता होती है।

Answer 15

ऐसा करने के लिए और E_STRICT से बचें और उस सरणी के आंतरिक पॉइंटर के साथ गड़बड़ न करें जिसका आप उपयोग कर सकते हैं:

function lelement($array) {return end($array);}

$last_element = lelement($array);

लेमेंट केवल एक कॉपी के साथ काम करता है ताकि यह एरे के पॉइंटर को प्रभावित न करे।

Answer 16

एक और समाधान:

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;

Answer 17

एक और संभव उपाय ...

$last_element = array_reverse( $array )[0];

Comments

साहचर्य सरणियों पर काम नहीं करना मुझे नीचा दिखाने के लिए पर्याप्त कारण की तरह नहीं लगता है। गुणवत्ता-वार यह उत्तर अधिक बुरा नहीं है और फिर इस प्रश्न के कई अन्य उत्तर। मुझे समझ में नहीं आता है कि मैं इस समय कम से कम 2 डाउनवोट क्यों देखता हूं। (स्कोर -2)। वैसे भी, मेरे लिए upvote, यह उतना बुरा नहीं है।

— पॉल वैन लीउवेन 20

Answer 18

कैसा रहेगा:

current(array_slice($array, -1))

• सहयोगी सरणियों के लिए काम करता है
• काम करता है जब $array == [](रिटर्न false)
• मूल सरणी को प्रभावित नहीं करता है

Answer 19

आप नीचे दिए गए तर्क का उपयोग करके आसानी से एक सरणी से अंतिम तत्व प्राप्त करेंगे

$array = array('a', 'b', 'c', 'd');
echo ($array[count($array)-1]);

न केवल अंतिम तत्व, बल्कि आप नीचे तर्क का उपयोग करके दूसरा अंतिम, तीसरा अंतिम और इसी तरह प्राप्त कर सकते हैं।

दूसरे अंतिम तत्व के लिए आपको उपरोक्त कथन में सिर्फ नंबर 2 पास करना होगा:
इको ($ सरणी [गिनती ($ सरणी) -2)));

Answer 20

ऐरे से अंतिम मूल्य प्राप्त करने के लिए:

array_slice($arr,-1,1) ;

अंतिम मान फ़ॉर्म निकालने के लिए:

array_slice($arr,0,count($arr)-1) ;

Comments

array_slice($arr,-1,1)लंबाई 1 के साथ एक और सरणी में परिणाम होगा, अंतिम तत्व नहीं

— विक

एक उदाहरण लेते हैं: $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); परिणाम:Array ( [0] => brown )

— ऋषभ

Answer 21

सीधे शब्दों में: $last_element = end((array_values($array)))

सरणी रीसेट नहीं करता है और STRICT चेतावनी नहीं देता है।

पुनश्च। चूँकि सबसे अधिक मत दिए गए उत्तर में अभी भी डबल कोष्ठक नहीं है, इसलिए मैंने यह उत्तर प्रस्तुत किया।

Answer 22

मुझे लगता है कि यह सभी मौजूदा उत्तरों पर थोड़ा सुधार है:

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;

• विशेष रूप से बड़े सरणियों के साथ, end()का उपयोग करके या समाधान से बेहतर प्रदर्शन करता हैarray_keys()
• सरणी के आंतरिक पॉइंटर को संशोधित नहीं किया जाएगा
• खाली सरणियों के लिए अपरिभाषित ऑफ़सेट तक पहुँचने का प्रयास नहीं करेंगे
• खाली सरणियों, अनुक्रमित सरणियों, मिश्रित सरणियों और साहचर्य सरणियों के लिए अपेक्षा के अनुरूप काम करेंगे

Comments

अफसोस की बात है कि यह साहचर्य सरणियों के साथ काम नहीं करता है, क्योंकि स्लाइस के एकल आइटम में एक नामित कुंजी हो सकती है।

— ग्रास डबल

आप ठीक हैं, एक फिक्स ( array_valuesएकल-तत्व स्लाइस पर) को जोड़ने के लिए संपादित

— एडेलमार

Answer 23

अंत () फ़ंक्शन का उपयोग करें।

$array = [1,2,3,4,5];
$last = end($array); // 5

Comments

बस ध्यान दें कि यह फ़ंक्शन आपके सरणी के पॉइंटर को उस स्थिति में ले जाता है।

— जियोनीनिड्स

यह भी ध्यान दें कि यह एक उत्तर के रूप में 8 साल पहले पोस्ट किया गया था। stackoverflow.com/a/3687368/1255289

— miken32

Answer 24

आजकल, मैं हमेशा इस सहायक को पसंद करूंगा, जैसा कि php.net/end जवाब में सुझाया गया है ।

<?php
function endc($array) {
    return end($array);
}

$items = array('one','two','three');
$lastItem = endc($items); // three
$current = current($items); // one
?>

यह हमेशा पॉइंटर को वैसा ही रखता है जैसा वह है और हमें कभी भी कोष्ठक, सख्त मानकों या जो भी हो, के बारे में चिंता करने की आवश्यकता नहीं होगी।

Comments

पहले ही ऊपर उल्लेख किया गया है: stackoverflow.com/a/45333947/1255289

— miken32

Answer 25

नोट: (PHP 7> = 7.3.0) के लिए हम array_key_last का उपयोग कर सकते हैं - किसी सरणी की अंतिम कुंजी बन जाती है

array_key_last ( array $array ) : mixed

Ref: http://php.net/manual/en/function.array-key-last.php

Comments

यह पहले से ही कई अन्य उत्तरों में शामिल था।

— miken32

लेकिन मैंने दूसरों की तुलना में पहले इसका जवाब दिया

— lokender singh

Answer 26

क्या होगा यदि आप सरणी के अंतिम तत्व को सरणी के लूप के अंदर लाना चाहते हैं?

नीचे दिए गए कोड का परिणाम अनंत लूप में होगा:

foreach ($array as $item) {
 $last_element = end($array);
 reset($array);
 if ($last_element == $item) {
   // something useful here
 }
}

गैर साहचर्य सरणियों के लिए समाधान स्पष्ट रूप से सरल है:

$last_element = $array[sizeof ($array) - 1];
foreach ($array as $key => $item) {
 if ($last_element == $item) {
   // something useful here
 }
}

Comments

मैं अंत () और रीसेट () कार्यों के बारे में जानता हूं। मेरी टिप्पणी फॉर्च जैसे छोरों से संबंधित थी या जहां आप इन कार्यों का उपयोग नहीं कर सकते, क्योंकि रीसेट फ़ंक्शन एक सरणी के आंतरिक पॉइंटर को रीसेट करता है जिसका उपयोग लूप में पुनरावृत्ति के लिए किया जाता है। इसके लिए खेद है, प्रश्न अधिक सरल था, मैं सिर्फ अपनी परियोजना में अधिक उन्नत स्थिति देना चाहता था। सादर।

— वादिम पॉडलेव्स्की

यह कई मायनों में गलत है (डुप्लिकेट के साथ सरणियां, गैर-सख्त तुलना ...) और किसी भी मामले में वास्तव में सवाल से संबंधित नहीं है।

— २२:१६ को

अंतिम तत्व प्राप्त करने के लिए अंत ($ सरणी) फ़ंक्शन का उपयोग करें, आप अनावश्यक रूप से लूप का उपयोग क्यों कर रहे हैं?

— महाक चौधरी

@MahakChoudhary मेरी टिप्पणी "अतिरिक्त का अंतिम तत्व कैसे प्राप्त करें अगर आप इस सरणी के एक लूप के अंदर पहले से ही कुछ जोड़तोड़ कर रहे हैं, तो अंत का उपयोग कर रहे हैं () अंत पारी का संकेत रीसेट करेगा और पुनरावृति लूप को तोड़ देगा। चीयर्स!

— वादिम पॉडलेव्स्की

Answer 27

$file_name_dm =  $_FILES["video"]["name"];    

                           $ext_thumb = extension($file_name_dm);

                            echo extension($file_name_dm); 
function extension($str){
    $str=implode("",explode("\\",$str));
    $str=explode(".",$str);
    $str=strtolower(end($str));
     return $str;
}

Answer 28

PHP 7.3 के रूप में, array_key_lastउपलब्ध है

$lastEl = $myArray[array_key_last($myArray)];

Comments

इसका उल्लेख कई अन्य उत्तरों में पहले ही किया जा चुका है।

— miken32

Answer 29

बहुत आसान

$array = array('a', 'b', 'c', 'd');
end($array)

Comments

यह उल्लेख करना है कि यह अजीब व्यवहार है यदि आप अंतराल के साथ सरणियों का उपयोग करते हैं। यानी $a = array(); $a[2] = 'c'; $a[1] = 'b'; echo end($a); लौटेंगेb

— साइमन ज़ीक्स

यह 9 साल पहले ही पोस्ट किया गया था। stackoverflow.com/a/3687368/1255289

— miken32

Answer 30

मेरा सरल समाधान, सुंदर और समझने में आसान।

array_reverse($array)[0];

Comments

इतना सरल यह 3 साल पहले पोस्ट किया गया था। stackoverflow.com/a/38977466/1255289

— miken32