配列の最後の要素を削除せずに取得する最良の方法は何ですか？

OK、

私はについてすべて知っています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

このスレッドの多くの回答は、さまざまなオプションを提供します。それらから選択できるようにするには、彼らの行動とパフォーマンスを理解する必要がありました。この答えでは、私は、あなたと私の調査結果を共有するPHPのバージョンをベンチマーク5.6.38、7.2.10および7.3.0RC1（2018年12月13日を予想しました）。

<<option code>>テストするオプション（s）は次のとおりです。

• オプション1。 $x = array_values(array_slice($array, -1))[0];（ rolacjaによって提案されたように）
• オプション2。 $x = array_slice($array, -1)[0];（示唆されるようにすることにより Stoutie）
• オプション.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);（示唆されるようにすることにより Iznogood）
• オプション.6。 $x = end((array_values($array)));（ TecBratによって提案された）
• オプション.7。 $x = $array[count($array)-1];（ Mirko Pagliaiが提案したように）
• オプション.8。 $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];（ thrauが提案したように）
• オプション.9。 $x = $array[] = array_pop($array);（示唆されるようにすることにより user2782001）
• オプション10. $x = $array[array_key_last($array)];（ Quasimodoのクローンで提案されているとおり、PHP 7.3で利用可能）

（機能が挙げ：array_key_last、array_keys、array_pop、array_slice、array_values、カウント、終了、リセット）

<<input code>>組み合わせるテスト入力（s）：

• null =$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>>のと<<input code>>の各組み合わせは、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し、1回の反復の平均継続時間をフェムト秒（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 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/ 

上記のF atal 、W arning、Nの oticeコードは、

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関数には、この記事の執筆時点ではまだRCであることを除いて、上記の制限はないようです（RCを使用するか、2018年12月のリリースを待ちます）。
  • オプション10. $x = $array[array_key_last($array)];（PHP 7.3以降）

配列をスタックとして使用するか、キューとして使用するかに応じて、オプション9を変更できます。

試す

$myLastElement = end($yourArray);

リセットするには（@hopeseekrに感謝）：

 reset($yourArray);

マニュアルへのリンク

@David Murdochが追加： $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 Tyncとみんなに感謝します！

短くて甘い。

エラーメッセージを削除し、ワンライナーフォームと効率的なパフォーマンスを維持するための解決策を思いつきました。

$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。

何が問題になっていarray_slice($array, -1)ますか？（マニュアルを参照：http : //us1.php.net/array_slice）

array_slice()配列を返します。おそらくあなたが探しているものではないでしょう。要素が必要です。

参照渡しエラー（たとえば、「end（array_values（$ foo））」）を回避する1つの方法は、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))));

内部ポインタを変更する必要がない場合（インデックス付き配列と連想配列の両方をサポート）：

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

記録のために、ここにある鉱山の別の答えは、配列の最初の要素のために、。

テストされていません：これはうまくいきませんか？

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

array_valuesによって返される配列は一時的なものであるため、そのポインターがリセットされても問題ありません。

それと一緒に行くための鍵が必要な場合、私はあなたがやると思います：

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

私はスタックを処理するためにこれを頻繁に必要とし、配列またはその内部ポインタを何らかの形で操作せずにそれを行うネイティブ関数はないことにいつも困惑しています。

そのため、通常は連想配列で安全に使用できるutil関数を持ち歩きます。

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

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

配列の最後の要素を取得するには、以下を使用します。

$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を使用しました。

end（）は配列の最後の要素を提供します

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

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

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

$lastValue = end(array_values($array))

$ arrayポインターは変更されません。これにより、

reset($array)

これは特定の条件では望ましくない場合があります。

私のために：

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

連想では：

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

上位の回答は素晴らしいですが、@ paul-van-leeuwenと@ quasimodos-cloneで言及されているように、PHP 7.3はこの問題を直接解決する2つの新しい関数、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以降が必要です。

これを行い、E_STRICTを回避し、配列の内部ポインターを混乱させないようにするには、次のように使用できます。

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

$last_element = lelement($array);

lelementはコピーでのみ機能するため、配列のポインターには影響しません。

別の解決策：

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

もう1つの可能な解決策...

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

どうですか：

current(array_slice($array, -1))

• 連想配列で機能します
• いつ動作するか$array == []（戻りfalse）
• 元の配列には影響しません

以下のロジックを使用すると、配列から最後の要素を簡単に取得できます

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

最後の要素だけでなく、以下のロジックを使用して、最後から2番目、最後から3番目などを取得することもできます。

2番目の最後の要素については、たとえば上記のステートメントで2番だけを渡す必要があります
。echo（$ array [count（$ array）-2]）;

Arrayから最後の値を取得する場合：

array_slice($arr,-1,1) ;

配列の最後の値を削除する場合：

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

単に： $last_element = end((array_values($array)))

配列をリセットせず、STRICT警告も出しません。

PS。最も投票された回答にはまだ二重括弧がないため、この回答を送信しました。

これは、既存のすべての回答を少し改善したものだと思います。

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

• 特に大規模なアレイでは、end()を使用した場合よりもパフォーマンスが優れているarray_keys()
• 配列の内部ポインタを変更しない
• 空の配列の未定義のオフセットにアクセスしようとしない
• 空の配列、インデックス付き配列、混合配列、および連想配列で期待どおりに機能します

end（）関数を使用します。

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

最近では、php.net / end answerで提案されているように、常にこのヘルパーを使用することをお勧めします。

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

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

これは常にポインタをそのまま維持し、括弧、厳密な基準などについて心配する必要はありません。

注：（PHP 7> = 7.3.0）の場合、array_key_last を使用できます—配列の最後のキーを取得します

array_key_last ( array $array ) : mixed

参照：http : //php.net/manual/en/function.array-key-last.php

配列のループ内にある配列の最後の要素を取得したい場合はどうなりますか？

以下のコードは無限ループになります：

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

$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;
}

PHP 7.3以降array_key_lastで利用可能

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

とてもシンプル

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

私のシンプルなソリューション、きれいで理解しやすい。

array_reverse($array)[0];