কোনও অ্যারেটি এটি মুছে না ফেলে শেষ উপাদানটি পাওয়ার সবচেয়ে ভাল উপায় কী?

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

এটি বিশ্বাস করুন বা এটিকে পপিং না করা এবং এটিকে পুনরায় চালু করা আমার পক্ষে এটি করা সবচেয়ে দ্রুততম উপায়। $ Val = $ অ্যারে [] = array_pop ($ অ্যারে); প্রতিধ্বনি $ ভাল;

— ব্যবহারকারী2782001

এই প্রশ্নটির ফলে অনেকগুলি বিকল্প ছিল in নিজেকে চয়ন করতে সহায়তা করার জন্য, আমি সর্বাধিক উল্লেখযোগ্য / স্বতন্ত্র বিকল্পগুলির তুলনা করেছি এবং ফলাফলগুলি পৃথক উত্তর হিসাবে ভাগ করেছি । (: @ user2782001 আমার উপরের মন্তব্যে আমার প্রিয় পরামর্শ দিয়েছে। :) অবদানের জন্য সবাইকে ধন্যবাদ!

— পল ভ্যান লিউউইন

@ থিওডোরআর স্মিথ যখন পিএইচপি 7.৩ প্রকাশিত হয়েছে তখন আপনি তৈরির কথা বিবেচনা করতে পারেন ( কোসিমোডোর ক্লোন দ্বারা দেওয়া এই পরামর্শটি 'স্বীকৃত উত্তর' (আপনার বিবেচনার জন্য) ...

— পল ভ্যান লিউউইন

Answer 1

এই থ্রেডের অনেক উত্তর আমাদের বিভিন্ন বিকল্পের সাথে উপস্থাপন করে। তাদের থেকে বাছাই করতে আমার তাদের আচরণ এবং অভিনয় বুঝতে হবে understand এই উত্তরে আমি আমার অনুসন্ধানগুলি আপনার সাথে ভাগ করব, পিএইচপি সংস্করণগুলির বিরুদ্ধে 5.6.38, 7.2.10এবং 7.3.0RC1( প্রত্যাশিত 13 ডিসেম্বর 2018 )।

বিকল্পগুলি ( <<option code>>গুলি) আমি পরীক্ষা করব:

• বিকল্প 1. $x = array_values(array_slice($array, -1))[0];( যেমন রোলকাজা দ্বারা প্রস্তাবিত )
• বিকল্প .2। $x = array_slice($array, -1)[0];( প্রস্তাবিত দ্বারা Stoutie )
• বিকল্প .3। $x = array_pop((array_slice($array, -1)));( যেমন রোলকাজা দ্বারা প্রস্তাবিত )
• বিকল্প .4। $x = array_pop((array_slice($array, -1, 1)));( ওয়েস্টি92 দ্বারা প্রস্তাবিত )
• বিকল্প .5। $x = end($array); reset($array);( প্রস্তাবিত দ্বারা Iznogood )
• বিকল্প .6। $x = end((array_values($array)));( টেকব্র্যাট দ্বারা প্রস্তাবিত হিসাবে )
• বিকল্প .7। $x = $array[count($array)-1];( মিরকো পাগলাইয়ের পরামর্শ অনুসারে)
• বিকল্প .8। $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( থ্রাউ দ্বারা প্রস্তাবিত হিসাবে )
• বিকল্প .9। $x = $array[] = array_pop($array);( ব্যবহারকারী2782001 দ্বারা প্রস্তাবিত হিসাবে )
• বিকল্প 10. $x = $array[array_key_last($array)]; ( হিসাবে প্রস্তাব দ্বারা Quasimodo এর ক্লোন ; পিএইচপি 7.3 প্রতি উপলব্ধ)

(উল্লিখিত ফাংশন: অ্যারে_কি_লাস্ট , অ্যারে_কিজ , অ্যারে_পপ , অ্যারে_স্লাইস , অ্যারে_ভ্যালু , গণনা , শেষ , পুনরায় সেট )

<<input code>>একত্রিত করতে পরীক্ষার ইনপুট ( গুলি):

• নাল =$array = null;
• খালি =$array = [];
• শেষ_নুল =$array = ["a","b","c",null];
• অটো_আইডিএক্স =$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 পিএইচপি ডকার পাত্রে ব্যবহার করব :

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

উপরের তালিকাভুক্ত <<option code>>ও গুলিগুলির প্রতিটি সংমিশ্রণ <<input code>>পিএইচপি-র সমস্ত সংস্করণে চলবে। প্রতিটি পরীক্ষার জন্য নিম্নলিখিত কোড স্নিপেট ব্যবহার করা হয়:

<<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.000000000000001th)।

ফলাফলগুলো নিম্নে প্রদর্শিত হল:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            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

এই ফলাফলের উপর ভিত্তি করে আমি নিম্নলিখিত সিদ্ধান্তগুলি আঁকছি:

• পিএইচপি-র নতুন সংস্করণগুলি এই বিকল্পগুলির ব্যতীত আরও ভাল সম্পাদন করে যা উল্লেখযোগ্যভাবে ধীর হয়ে পড়ে:
  • বিকল্প .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);
  • বিকল্প ১০. $x = $array[array_key_last($array)]; (পিএইচপি 7.৩ থেকে)
• এই বিকল্পগুলি কেবল স্ব-সূচকযুক্ত অ্যারেগুলির জন্য ব্যবহার করা উচিত :
  • বিকল্প .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):
  • বিকল্প ১০. $x = $array[array_key_last($array)]; (পিএইচপি 7.৩ থেকে)

অ্যারেটি স্ট্যাক হিসাবে বা কাতার হিসাবে ব্যবহার করে আপনি বিকল্প 9 তে বিভিন্নতা আনতে পারেন তার উপর নির্ভর করে কিছুটা ।

Comments

যদি আপনি হারিয়ে যাওয়ার জন্য কোনও বিশেষ বিকল্প খুঁজে পান তবে উপরের কোড স্নিপেটগুলি এক সাথে অনুলিপি করে এটি পূর্বের পরীক্ষিত বিকল্পের সাথে তুলনা করে পরীক্ষা করতে পারেন। এই তালিকায় একটি বিকল্প যুক্ত করতে তুলনামূলক পারফরম্যান্স ফলাফলের জন্য সমস্ত সংমিশ্রণের পুনরায় পরীক্ষা করা হবে। আপনার যদি মনে হয় কোনও বিশেষ বিকল্প যা আপনার যুক্ত করা উচিত বলে মনে করেন তবে দয়া করে একটি মন্তব্য ফেলে দিন, আমি এটি যুক্ত করতে চাই (যদিও এটি কিছুটা সময় নিতে পারে)।

— পল ভ্যান লিউউয়েন

খুব দুর্দান্ত উত্তর, যদিও একটি মন্তব্য: এসোসিয়েটিভ অ্যারে বিকল্পগুলির জন্য 9 টিও খুব বেশি ব্যবহার করা যায় না, কারণ আমরা আগের কী নামের পরিবর্তে একটি স্বয়ংক্রিয় সূচক কীতে আবার বরাদ্দ করছি।

— গ্রাস ডাবল

চমৎকার সারসংক্ষেপ! দয়া করে নতুন উত্তর পিএইচপি 7.3 ব্যবহার করে আমার উত্তর যুক্ত করুন । ফাংশন $array[array_key_last($array)];আপনার বেঞ্চমার্ক করতে। এবং সম্পূর্ণ হয়ে গেলে আমাকে কিছু বিজ্ঞপ্তি দিন। আমি তুলনায় পারফরম্যান্স ফলাফল দেখতে চাই।

— কোসিমোডোর ক্লোন

@ এসজেড এটি মূলত প্রচুর জেদ এবং ধৈর্য সহ উত্পাদিত হয়েছিল তবে সাব্লাইম টেক্সট সম্পাদকের সাধারণ নির্বাচন এবং বহু-লাইন সম্পাদনা কার্যগুলি সহায়তা করেছিল। এটি পুনরুত্পাদন করতে প্রায় এক দিন সময় লেগেছিল, সুতরাং আমার যদি আবার এটির প্রয়োজন হয় তবে আমি সম্ভবত এমন কিছু লিখব যা 210 ডকারের মৃত্যুদণ্ডের ফলাফলকে স্বয়ংক্রিয়ভাবে একটি টেবিলে রূপান্তর করে :-)

— পল ভ্যান লিউউইন

@ কোসিমোডোস-ক্লোন আমি সর্বশেষ প্রকাশিত পিএইচপি 5, 7 এবং আপনার আরসির উপর ভিত্তি করে পুরো টেবিলটি পুনরায় জেনারেট করেছি। আমি মনে করি আমরা আসন্ন ডিসেম্বরে আসার পরে আবার এটি তৈরি করতে চাই। এই নতুন ফাংশনটি সবার নজরে আনার জন্য ধন্যবাদ।

— পল ভ্যান লিউউইন

Answer 2

চেষ্টা

$myLastElement = end($yourArray);

এটি পুনরায় সেট করতে (ধন্যবাদ @ হোপিসেকার):

 reset($yourArray);

ম্যানুয়াল লিঙ্ক

@ ডেভিড মুরডোক যোগ করেছেন: E_STRICT এ $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). এটি সতর্কতা উত্পন্ন করে

Strict Standards: Only variables should be passed by reference

ধন্যবাদ o_O Tync এবং সবাইকে!

Comments

ব্যবহার করুন $myLastElement = end(array_values($yourArray));এবং এখন আপনাকে কল করার দরকার নেই reset()।

— ডেভিড মারডোক

@ ডেভিড মুরডোক সম্ভবত, তবে এটি নিশ্চিত করে যে র‌্যাম এবং সিপিইউ মন্থন করে, অ্যারের মানগুলির জন্য অস্থায়ী অ্যারে তৈরি করে ...

— থিওডোর আর স্মিথ

যদি আপনার সার্ভারটি খুব বেশি র‍্যাম গ্রহণ করে যাতে কোনও সাধারণ অতিরিক্ত ফাংশন কল করা একটি চুক্তি বিভাজক হয় তবে আমি আপনাকে পরামর্শ দিচ্ছি যে আপনি আপনার সার্ভারের কনফিগারেশন এবং সংস্থানগুলি পুনরায় পরীক্ষা করতে পারেন।

— ক্রিস বেকার

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

ঠিক 5 বছর, 6 মাস 2 দিন পরে, আপনি আরও উচ্চতর উত্তর জমা দিয়েছেন !! ধন্যবাদ! এবং স্ট্যাক ওভারফ্লো ধন্যবাদ!

— থিওডোর আর স্মিথ

উত্তরের উত্তর, তবে অতিরিক্ত বন্ধনী যুক্ত করা কিছুটা হ্যাকিশ মনে হচ্ছে। এছাড়াও phpStorm এটিকে ত্রুটি হিসাবে চিহ্নিত করবে। অতিরিক্ত বন্ধনী যুক্ত করার জন্য অতিরিক্ত তথ্য ( phpsadness.com/sad/51 )। ত্রুটিটি কাটিয়ে উঠতে আপনি এটি একটি '2-লাইনার' বানাতে পারেন: $array = array_slice($array, -1); $lastEl = array_pop($array);ব্যক্তিগতভাবে আমি মনে করি এটি ভাল (পার্সার 'বাগ' ছাড়াই)

— মরিস

আপনি এর মতো ডেরিফারেন্সিং ব্যবহার করতে পারেন: অ্যারে_স্লাইস ($ অ্যারে, -1) [0]

— বিকাশ

অ্যারেতে সূচক হিসাবে আপনার কাছে স্ট্রিং থাকলে আপনি পারবেন না

— রোজক

এই উত্তরটির পিএইচপি বিজ্ঞপ্তি এড়াতে এখনও কমপক্ষে দুটি চেক প্রয়োজন। 1. চেক করুন কিনা array_size() > 1 ২। অ্যারেটি আসলে একটি অ্যারে কিনা তা পরীক্ষা করে দেখুন। পিএইচপি-র অন্তর্নির্মিত end()ফাংশনটি ইতিমধ্যে সমস্ত কঠোর পরিশ্রম আরও দক্ষ পদ্ধতিতে করে চলেছে বলে আমি এখনও @ ইজনোগুডের জবাবটি আটকে রেখেছি ।

— Ema4rl

Answer 4

এর সাথে কী হয়েছে array_slice($array, -1)? (ম্যানুয়াল দেখুন: http://us1.php.net/array_slice )

array_slice()একটি অ্যারে প্রদান করে। সম্ভবত আপনি যা খুঁজছেন তা নয়। আপনি উপাদান চান।

Comments

array_slice($array, -1)[0]উপাদান পেতে ব্যবহার করুন ।

— পাইং

এই উত্তর। "শেষ" অ্যারের অভ্যন্তরীণ পয়েন্টারটি পরিবর্তন করছেন? কষ্টের জন্য জিজ্ঞাসা, এবং পড়া খুব কঠিন!

— জেরার্ড ওনিল

এই পন্থাটি পছন্দ করুন, যদিও @ প্যাং যেমন উল্লেখ করেছেন, এটি সম্পূর্ণ সম্পূর্ণ নয়। reset(array_slice($array, -1))অন্য পদ্ধতির (এটি array_slice()একটি একক-উপাদান অ্যারের চেয়ে "ছোট" কিছু ফেরত দিলে ত্রুটি সৃষ্টি করবে না )

— রিনোগো

সেরা উপাদানটি আপনি সরাসরি উপাদানটি সংশোধন করতে পারবেন:array_slice($array, -1)[0] = "";

— হ্যালেক্স

Answer 5

পাস-বাই-রেফারেন্স ত্রুটিগুলি এড়ানোর একটি উপায় (যেমন "শেষ (অ্যারে_ভ্যালু ($ ফু))") হ'ল কল_উজার_ফুনক বা কল_উজার_ফুনক_আর্রে ব্যবহার:

// 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)))

— ডিজনেয়েট

অতিরিক্ত বন্ধনীর কৌশলটি পিএইচপি-র একটি বাগের উপর নির্ভর করে এবং এই পদ্ধতিটি পিএইচপি পরবর্তী সংস্করণগুলিতে আর কাজ করে না (বা কমপক্ষে, পিএইচপি 7 তে নয়)।

— ম্যাট ব্রাউন

আর call_user_funcকৌতুকটি পিএইচপি 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);
}

নোট করুন যে পিএইচপি "অন-দ্য ফ্লাই" অনুলিপি তৈরি করে, অর্থাত্ যখন কেবল প্রয়োজন হয়। দ্যend()নিজেই অ্যারে, তাই অভ্যন্তরীণভাবে অ্যারের একটি কপি উৎপন্ন হয় পরিবর্তন।

সুতরাং, নিম্নোক্ত বিকল্পটি প্রকৃতপক্ষে দ্রুততর হিসাবে অভ্যন্তরীণভাবে এটি অ্যারে অনুলিপি করে না, এটি কেবল একটি টুকরো করে তোলে:

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

প্রথম "(এবং এখানে একক) আইটেমটি দক্ষতার সাথে পাওয়ার জন্য এই" ফোরচ / রিটার্ন "একটি টুইঙ্ক।

অবশেষে, কেবলমাত্র তালিকাবদ্ধ অ্যারেগুলির জন্য দ্রুততম বিকল্প:

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

---

রেকর্ডের জন্য, অ্যারের প্রথম উপাদানটির জন্য আমার এখানে আরও একটি উত্তর ।

Comments

আপনি একটি array_lastফাংশন জন্য 2 বিকল্প বাস্তবায়ন সরবরাহ । প্রথমটির জন্য আপনি জানিয়েছেন যে $arrayঅনুলিপি করা হয়েছে এবং দ্বিতীয়টির জন্য এটি অনুলিপি করা হয়নি। কোথায় পার্থক্য আছে / কেন এটি প্রথম প্রয়োগে অনুলিপি করা হয় এবং দ্বিতীয়টিতে নয়?

— পল ভ্যান লিউউইন

@ পলভলানউইউউইন আমি বুঝতে পেরেছি আপনি কেন বিভ্রান্ত হয়েছেন। আমি উত্তরটি পরিষ্কার করার চেষ্টা করেছি , এটি কি আরও ভাল?

— গ্রাস ডাবল

Answer 7

অপরিশোধিত: এই কাজ করবে না?

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

যেহেতু অ্যারে_ভ্যালু দ্বারা অ্যারে ফিরে এসেছে তা ক্ষণস্থায়ী, কেউ যদি তার পয়েন্টারটি পুনরায় সেট করা হয় তবে কেয়ার করে না।

এবং এটির সাথে যেতে যদি আপনার কীটির প্রয়োজন হয় তবে আমি অনুমান করি আপনি করতে পারেন:

<?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

সুসংবাদ, তারা এটিকে একটি স্থানীয় ফাংশন তৈরি করছে :-) আপনি এখানে এটির মুক্তির পরিকল্পনার দিকে নজর রাখতে পারেন: উইকি.এফপি.এন.পি / টোডো / পিপিপি 73 (এই লেখার সময় প্রত্যাশিত ডিসেম্বর 13 2018)।

— পল ভ্যান লিউউইন

Answer 9

একটি অ্যারের শেষ উপাদানটি পেতে, ব্যবহার করুন:

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

মাপকাঠি

আমি ছোট করে 1000 বার পুনরাবৃত্তি করেছি, যথাক্রমে 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...

আমি পিএইচপি সংস্করণ 5.5.32 ব্যবহার করেছি।

Comments

$ অ্যারে [অ্যারে_কিজ ($ অ্যারে) [গণনা (অ্যারে_কিজ ($ অ্যারে)) - 1]] ব্যবহার সম্পর্কে কী?

— ব্যবহারকারী2782001

hmm..array_keys বেশ খারাপভাবে স্কেল করেছে বলে মনে হচ্ছে।

— user2782001

আইটেমটি পপ করার জন্য এটি বড় অ্যারে (0.0002) এর জন্য দ্রুত পাগল ... ... $ ভাল = $ আর [] = $ অ্যারে_পপ ($ আর);

— user2782001

@ Westy92 আপনার ইউনিটগুলি মানদণ্ডে ভুল বলে মনে হচ্ছে। আপনার দেওয়া সবচেয়ে ছোট সংখ্যাটি 0.00031 ... মাইক্রোসেকেন্ড যা প্রায় 0.3 ন্যানোসেকেন্ড। এর অর্থ হ'ল যদি আপনার নতুন কম্পিউটার থাকে তবে আপনার পরীক্ষাটি চালনার জন্য একটি ঘড়ির টিক নিয়েছিল। আমি অনুমান করছি আপনি হয় মিলিসেকেন্ড বা সম্ভবত এমনকি কয়েক সেকেন্ড বোঝাতে চাইছেন ।

— সিসয়েড

মানগুলি স্পষ্টতই ভুলগুলির একাধিক আদেশ। কেন যেভাবেই পারফরম্যান্সে ফোকাস?

— 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

এই সমাধানটি কাজ করে, তবে এটি অ্যারের অভ্যন্তরীণ পয়েন্টার পরিবর্তন করে, আমি মনে করি এটি সঠিক উপায় নয়।

— ইউনিক্সএইগেইন

Answer 11

পিএইচপি সংস্করণ 7.3 হিসাবে ফাংশন array_key_firstএবং array_key_lastচালু করা হয়েছে।

যেহেতু পিএইচপি-তে অ্যারেগুলি কঠোর অ্যারে প্রকার নয়, অর্থাত্ সূচক 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

আপনার উত্তরের জন্য কিছু প্রসঙ্গ সরবরাহ করুন।

— শান

@ শন কোন প্রসঙ্গে? প্রসঙ্গে দরকার নেই। সহযোগী অ্যারেগুলির জন্য কোড যুক্ত করা হয়েছে।

— মিরকো পাগলাই

Answer 14

শীর্ষস্থানীয় উত্তরগুলি দুর্দান্ত, তবে @ পল-ভ্যান-লিউউইন এবং @ কোসিমোডোস-ক্লোন দ্বারা উল্লিখিত হিসাবে, পিএইচপি 7.3 এই সমস্যাটি সরাসরি সমাধান করার জন্য দুটি নতুন ফাংশন প্রবর্তন করবে - অ্যারে_কি_ফর্স্ট () এবং অ্যারে_কি_লাস্ট () ।

আপনি আজ এই সিনট্যাক্সটি নীচের পলিফিল (বা শিম) ফাংশন ব্যবহার করে শুরু করতে পারেন।

// 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)];

কেভেট: এর জন্য পিএইচপি 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)। যাইহোক, আমার জন্য আপভোট করুন, এটি খারাপ নয়।

— পল ভ্যান লিউউয়েন

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)))

অ্যারেটিকে পুনরায় সেট করে না এবং স্ট্রাইক সতর্কতা দেয় না।

পুনশ্চ. যেহেতু সর্বাধিক ভোট দেওয়া উত্তর এখনও ডাবল প্রথম বন্ধনী নেই, আমি এই উত্তরটি জমা দিয়েছি।

Answer 22

আমি মনে করি বিদ্যমান বিদ্যমান জবাবগুলির এটি সামান্য উন্নতি:

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

• বিশেষত বড় অ্যারে end()ব্যবহার করে বা এর চেয়ে বেশি সমাধান করে array_keys()Per
• অ্যারের অভ্যন্তরীণ পয়েন্টারটি পরিবর্তন করবে না
• খালি অ্যারেগুলির জন্য একটি অপরিজ্ঞাত অফসেট অ্যাক্সেস করার চেষ্টা করবেন না
• খালি অ্যারে, সূচকযুক্ত অ্যারে, মিশ্রিত অ্যারে এবং সহযোগী অ্যারেগুলির প্রত্যাশার মতো কাজ করবে

Comments

দুঃখজনকভাবে এটি মিশুক অ্যারেগুলির সাথে কাজ করে না, কারণ স্লাইসের একক আইটেমটির একটি নামযুক্ত কী থাকতে পারে।

— গ্রাস ডাবল

আপনি ঠিক বলেছেন, একটি ফিক্স যুক্ত করার জন্য সম্পাদিত ( array_valuesএকক-উপাদান স্লাইসে)

— অ্যাডেলমার

Answer 23

শেষ () ফাংশনটি ব্যবহার করুন।

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

Comments

কেবল মনোযোগ দিন যে এই ফাংশনটি আপনার অ্যারের পয়েন্টারটিকে সেই অবস্থানে নিয়ে যায়।

— giovannipds

এটি 8 বছর আগের উত্তর হিসাবে পোস্ট করা হয়েছিল যে মনোযোগ দিন। stackoverflow.com/a/3687368/1255289

— miken32

Answer 24

আজকাল, আমি সবসময় এই সাহায্যকারীকে পছন্দ করতাম, যেমন একটি পিএইচপি.এন.এন্ড উত্তরটিতে পরামর্শ দেওয়া হয়েছিল ।

<?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

দ্রষ্টব্য: (পিএইচপি 7> = 7.3.0) এর জন্য আমরা অ্যারে_কি_লাস্ট ব্যবহার করতে পারি - একটি অ্যারের শেষ কীটি পাওয়া যায়

array_key_last ( array $array ) : mixed

তথ্যসূত্র: http://php.net/manual/en/function.array-key-last.php

Comments

এটি ইতিমধ্যে অন্য একাধিক উত্তরে wasাকা ছিল।

— মিকেন 32

তবে আমি এর আগে অন্যদের চেয়ে উত্তর দিয়েছি

— 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

আমি শেষ () এবং রিসেট () ফাংশন সম্পর্কে জানি। আমার মন্তব্যটি ফোরচের মতো লুপগুলির সাথে সম্পর্কিত ছিল বা আপনি যেখানে এই ফাংশনগুলি ব্যবহার করতে পারবেন না কারণ রিসেট ফাংশনটি অ্যারের অভ্যন্তরীণ পয়েন্টারটিকে পুনরায় সেট করে যা পুনরাবৃত্তির জন্য লুপে ব্যবহৃত হয়। এর জন্য দুঃখিত, প্রশ্নটি আরও সহজ ছিল, আমি কেবলমাত্র আমার প্রকল্পে এসে আরও উন্নত পরিস্থিতি দিতে চেয়েছিলাম। শুভেচ্ছান্তে.

— ভাদিম পোদলেভস্কি

এটি বিভিন্ন উপায়ে ভুল (ডুপ্লিকেটগুলির সাথে অ্যারে, অ-কঠোর তুলনা ...) এবং কোনও ক্ষেত্রেই সত্যিকার অর্থে প্রশ্নের সাথে সম্পর্কিত নয়।

— Tgr

শেষ উপাদানটি পেতে (অ্যারে ফাংশনটি ব্যবহার করুন, আপনি অযথা লুপগুলি কেন ব্যবহার করছেন?

— মহাক চৌধারী

।। @MahakChoudhary আমার মন্তব্য "কিভাবে অ্যারের শেষ উপাদান পেতে যদি আপনি কিছু হেরফেরের ইতিমধ্যে করছেন এই অ্যারের একটি লুপ ভিতরে শেষ () ব্যবহার innver পয়েন্টার রিসেট করুন এবং পুনরাবৃত্তির লুপ চিয়ার্স ভঙ্গ করবে একটি সংযোজন

— ভাদিম Podlevsky

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

পিএইচপি 7.3 হিসাবে array_key_lastউপলব্ধ

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

Comments

এটি ইতিমধ্যে আরও একাধিক উত্তরে উল্লেখ করা হয়েছে।

— মিকেন 32

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