배열의 마지막 요소를 삭제하지 않고 얻는 가장 좋은 방법은 무엇입니까?

427

확인,

에 대해 모두 알고 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  arrays 
— 시어 도어 R. 스미스
소스
11
그것을 믿거 나 터뜨리지 않는 것이 내가 이것을 벤치마킹 한 가장 빠른 방법 중 하나입니다. $ val = $ array [] = array_pop ($ array); 에코 $ val;
— user2782001
2
이 질문은 많은 옵션을 가져 왔습니다. 스스로 선택하는 데 도움이되도록, 가장 주목할만한 / 고유 한 옵션을 비교하고 그 결과 를 별도의 답변으로 공유했습니다 . (: @ user2782001은 위의 의견에서 지금까지 내가 가장 좋아하는 것을 제안했습니다. :) 기여해 주셔서 감사합니다!
— Paul van Leeuwen
1
@TheodoreRSmith PHP 7.3이 출시 될 때 ( Quasimodo의 클론 이 '허용 된 답변'을 고려한) 제안 을 고려할 수 있습니다 ...
— Paul van Leeuwen

답변:

175

이 스레드의 많은 답변은 많은 다른 옵션을 제시합니다. 그들로부터 선택할 수 있으려면 그들의 행동과 성과를 이해해야했습니다. 이 대답에 나는 PHP 버전에 대한 벤치마킹, 당신과 함께 내 연구 결과를 공유 할 것 5.6.38, 7.2.10그리고 7.3.0RC1( 2018 12월 13일 예상 ).

<<option code>>테스트 할 옵션 은 다음과 같습니다.

(언급 된 함수 : array_key_last , array_keys , array_pop , array_slice , array_values , count , end , reset )

테스트 입력 <<input code>>은 다음과 결합됩니다.

  • 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>>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는 마지막으로 검색된 테스트 입력의 마지막 값을 반환하고 한 반복의 평균 지속 시간을 펨토초 (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의 아탈은 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를 변경할 수 있습니다.

— 폴 반 리우 웬
소스
특정 옵션이 누락 된 경우 위의 코드 스 니펫을 복사하여 붙여 넣어 이전에 테스트 한 옵션과 비교하여 직접 테스트 할 수 있습니다. 이 목록에 옵션을 추가하는 것은 비슷한 성능 결과를 위해 모든 조합을 다시 테스트하는 것입니다. 추가해야 할 특정 옵션이 있으면 의견을 삭제하십시오. 그런 다음 추가하려고합니다 (시간이 걸릴 수 있음).
— Paul van Leeuwen
1
매우 큰 대답, 한 가지 의견 : 연관 배열의 경우 옵션 9도 사용할 수 없습니다. 이전 키 이름 대신 자동 색인 키에 다시 할당하기 때문입니다.
— Gras Double
1
좋은 요약! 새로운 PHP 7.3을 사용하여 답변 을 추가하십시오 . $array[array_key_last($array)];벤치 마크에 기능 . 완료되면 알려주십시오. 성능 결과를 비교하고 싶습니다.
— Quasimodo의 클론
2
@sz는 주로 고집과 인내심으로 제작되었지만 Sublime 텍스트 편집기의 일반적인 선택 및 여러 줄 편집 기능이 도움이되었습니다. 내가 다시 할 필요가 그렇다면, 그것은 거의 일했다 재생 나는 것입니다 아마 쓰기 뭔가 그 변환 :-) 자동으로 테이블에 대한 모든 (210 개) 고정 표시기의 실행의 출력
— 폴 밴 Leeuwen
1
@ quasimodos-clone 최신 릴리즈의 PHP 5, 7 및 RC를 기반으로 전체 테이블을 재생성했습니다. 12 월에 실제로 출시 될 때 다시 생성하고 싶다고 생각합니다. 이 새로운 기능을 모든 사람들의 관심에 가져 주셔서 감사합니다.
— Paul van Leeuwen
487

시험 

$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와 여러분!

— 이즈 노굿
소스
38
사용하면 $myLastElement = end(array_values($yourArray));이제 전화 할 필요가 없습니다 reset().
— David Murdoch
5
@DavidMurdoch 어쩌면 RAM과 CPU를 떨쳐 서 배열 값에 대한 임시 배열을 만듭니다.
— Theodore R. Smith
12
서버가 너무 많은 RAM을 사용하여 하나의 간단한 추가 기능을 호출하는 것이 거래 중단 인 경우 서버의 구성 및 리소스를 다시 검토하는 것이 좋습니다.
— Chris Baker
3
end(array_values())E_STRICT을 줄 것이다 "변수 만이 참조에 의해 전달되어야한다"
— kolypto
32
엄격한 경고를 피하기 위해 추가 괄호를 추가하십시오.end((array_values($yourArray)))
— Daniel W.
212

짧고 달다.

오류 메시지를 제거하고 단일 라이너 양식과 효율적인 성능을 유지하는 솔루션을 생각해 냈습니다.

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

— 롤라 키
소스
31
정확히 5 년, 6 개월 및 2 일 후에 더 우수한 답변을 제출했습니다 !! 감사합니다! 스택 오버플로 감사합니다!
— Theodore R. Smith
1
답을 맞이하지만 추가 괄호를 추가하면 약간의 어려움이 있습니다. 또한 phpStorm은 이것을 오류로 표시합니다. 추가 괄호를 추가하기위한 추가 정보 ( phpsadness.com/sad/51 ). 오류를 극복하기 위해 이것을 '2 라이너'로 만들 수 있습니다. $array = array_slice($array, -1); $lastEl = array_pop($array);개인적으로 이것이 파서 '버그'없이 더 나은 것으로 생각합니다.
— Maurice
3
다음과 같이 역 참조를 사용할 수 있습니다 : array_slice ($ array, -1) [0]
— Vikash
1
배열에서 인덱스로 문자열을 가지고 있다면
— rolacja
3
이 답변에는 PHP 통지를 피하기 위해 최소한 두 가지 점검이 필요합니다. 1. 있는지 확인 array_size() > 1 2. 배열이 실제로 배열되어 있는지 확인합니다. PHP의 내장 end()함수가 이미 모든 효율적인 작업을보다 효율적으로 수행 하기 때문에 @Iznogood의 대답을 고수 합니다.
— Ema4rl
37

무슨 일이야 array_slice($array, -1)? (매뉴얼 : http://us1.php.net/array_slice 참조 )

array_slice()배열을 반환합니다. 아마 당신이 찾고있는 것이 아닙니다. 당신은 요소를 원한다.

— 스타 우티
소스
21
array_slice($array, -1)[0]요소를 얻는 데 사용하십시오 .
— Pang
2
이것이 답입니다. "end"배열의 내부 포인터를 변경 하시겠습니까? 문제를 묻는 중이며 읽기가 매우 어렵습니다!
— Gerard ONeill
@Pang이 지적했듯이 완벽하지는 않지만이 접근법을 좋아하십시오. reset(array_slice($array, -1))또 다른 접근 방식입니다 ( array_slice()단일 요소 배열보다 "작은 것"을 반환 하면 오류가 발생하지 않습니다 )
— rinogo
요소를 직접 수정할 수있는 가장 좋은 방법은 다음과 같습니다.array_slice($array, -1)[0] = "";
— HAlex
20

참조 별 통과 오류를 방지하는 한 가지 방법 (예 : "end (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))));
— 워보
소스
훌륭한 접근 방식! (표준 '이것은 허용되는 답변이어야합니다'를 여기에 삽입하십시오)
— Typo
3
또는 추가 마비를 추가하십시오. 짧고 감미로운 :end((array_values($yourArray)))
— Dzhuneyt
4
추가 괄호 속임수는 PHP의 버그에 의존하며, 이후의 PHP 버전에서는 더 이상 작동하지 않습니다 (또는 적어도 PHP 7에서는 작동하지 않음).
— 매트 브라운
1
그리고 call_user_func트릭은 PHP 7에서도 작동하지 않습니다. 임시 변수를 만드는 데 어려움을 겪고 있다고 생각합니다.
— 매트 브라운
15

내부 포인터를 수정하지 않아도되는 경우 (인덱싱 및 연관 배열 모두 지원) :

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


레코드 의 경우 배열의 첫 번째 요소에 대한 또 다른 대답이 있습니다.

— 그라 더블
소스
array_last함수에 대해 2 개의 대체 구현을 제공 합니다. 첫 번째의 $array경우 복사 된 상태 이고 두 번째의 경우 복사되지 않은 상태입니다 . 차이점은 무엇이며 왜 두 번째가 아닌 첫 번째 구현에서 복사됩니까?
— Paul van Leeuwen
1
@PaulvanLeeuwen 왜 당신이 혼란 스러웠는지 이해했습니다. 나는 대답 을 명확히 하려고 노력했다 .
— Gras Double
10

테스트되지 않은 :이 작동하지 않습니까?

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

array_values에 의해 반환 된 배열이 멈 췄기 때문에 아무도 포인터가 재설정되는지 신경 쓰지 않습니다.

그리고 당신이 그것을 가지고 갈 열쇠가 필요하다면 나는 당신이 할 것이라고 생각합니다 :

<?php
$last_key=end(array_keys($array));
?>
— TecBrat
소스
9

스택을 처리하려면이 작업이 자주 필요하며 배열이나 내부 포인터를 어떤 형태로 조작하지 않고도 기본 기능이 없다는 것을 항상 당혹스럽게 생각합니다.

그래서 일반적으로 연관 배열에서도 사용하기에 안전한 util 함수를 사용합니다.

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

    $keys = array_keys($array);
    return $array[$keys[sizeof($keys) - 1]];
}
— 스 라우
소스
1
희소식, 그들은 그것을 네이티브 함수로 만들고 있습니다 :-) wiki.php.net/todo/php73 (이 글을 쓰는 시점에서 2018 년 12 월 13 일 예상) 에서 릴리스 계획을 계속 지켜 볼 수 있습니다 .
— Paul van Leeuwen
9

배열의 마지막 요소를 얻으려면 다음을 사용하십시오.

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

기준

나는 각각 100과 50,000 개의 요소를 포함하는 작은 배열과 큰 배열의 마지막 요소를 잡아서 1,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를 사용했습니다.

— Westy92
소스
$ array [array_keys ($ array) [count (array_keys ($ array))-1]]를 사용하는 것은 어떻습니까?
— user2782001
hmm..array_keys는 확장 성이 떨어지는 것 같습니다.
— user2782001
1
큰 배열 (0.0002)이 아이템을 팝하고 다시 놓는 것이 실제로 더 빠릅니다 ... $ val = $ ar [] = $ array_pop ($ ar);
— user2782001
1
@ Westy92 당신의 단위는 벤치 마크에서 틀린 것 같습니다. 가장 작은 숫자는 0.00031 ... 마이크로 초 이며 약 0.3 나노초입니다. 그것은 당신이 새로운 컴퓨터를 가지고 있다면 테스트를 실행하는 데 한 번의 틱이 걸린다는 것을 의미합니다. 난 당신이 중 하나를 의미 같은데요 밀리 초 또는 어쩌면 초 .
— cesoid
1
값은 분명히 몇 배 정도 잘못되었습니다. 어쨌든 성능에 중점을 둔 이유는 무엇입니까?
— istepaniuk
6

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
— 아지 스
소스
1
이 솔루션은 작동하지만 배열의 내부 포인터를 변경하지만 올바른 방법이라고 생각하지 않습니다.
— UnixAgain
5

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)];
— 콰지모도의 클론
소스
1
모두의 관심을 끌게 해주셔서 감사합니다. 이것을 사용하기를 간절히 원하는 사람들을 위해 :이 글을 쓰는 시점에서 이것이 RC라는 점을 잊지 마십시오. 그것은 2018 년 출시 12월 예정이다
— 폴 밴 Leeuwen에게
1
좋은 소식입니다. 방금 사람들 이이 구문을 즉시 사용할 수 있도록 아래 답변 에 polyfill / shim을 게시 했습니다.
— Mark Thomson
3 
$lastValue = end(array_values($array))

$ array 포인터는 수정되지 않습니다. 이것은 피한다

reset($array)

특정 조건에서는 바람직하지 않을 수 있습니다.

— 비한 베르 마
소스
3

나를 위해 :

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

연관성있는 경우 :

$last =array_values($array)[count($array - 1)]
— 미르코 팔리 아이
소스
답변에 대한 컨텍스트를 제공하십시오.
— Shawn
2
@Shawn 어떤 컨텍스트? 문맥이 필요하지 않습니다. 연관 배열에 대한 코드를 추가했습니다.
— Mirko Pagliai
3

최고의 답변은 훌륭하지만 @ paul-van-leeuwen 및 @ quasimodos-clone에서 언급했듯이 PHP 7.3 은이 문제를 직접 해결하기 위해 array_key_first () 및 array_key_last () 두 가지 새로운 기능을 도입 합니다.

다음 폴리 필 (또는 shim) 함수를 사용하여이 구문을 오늘 사용할 수 있습니다. 

// 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 이상이 필요합니다.

— 마크 톰슨
소스
2

이렇게하고 E_STRICT를 피하고 배열의 내부 포인터를 엉망으로 만들지 않으려면 다음을 사용할 수 있습니다.

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

$last_element = lelement($array);

lelement는 복사본에서만 작동하므로 배열의 포인터에는 영향을 미치지 않습니다.

— 다미 엔
소스
2

다른 해결책 :

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;
— 주세페 갈로
소스
2

하나 더 가능한 해결책 ...

$last_element = array_reverse( $array )[0];
— 찰스 수비대
소스
연관 배열에서 작업하지 않는 것은 나에게 공감할 충분한 이유가 아닌 것 같습니다. 품질면 에서이 답변은이 질문에 대한 다른 많은 답변보다 나쁘지 않습니다. 현재 최소 2 개의 다운 보트가 표시되는 이유를 모르겠습니다. (-2의 점수). 어쨌든, 나를 위해 투표, 그것은 그렇게 나쁘지 않습니다.
— Paul van Leeuwen
2

어때요 :

current(array_slice($array, -1))
  • 연관 배열에 사용
  • 때 작동합니다 $array == [](반환 false)
  • 원래 배열에 영향을 미치지 않습니다
— 부케 베르 슈
소스
2

아래 논리를 사용하여 배열에서 마지막 요소를 쉽게 얻을 수 있습니다.

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

마지막 요소뿐만 아니라 아래 논리를 사용하여 두 번째, 세 번째 등을 얻을 수 있습니다.

두 번째 마지막 요소의 경우 위 명령문에서 숫자 2 만 전달하면됩니다. 예 :
echo ($ array [count ($ array) -2]);

— 암 자드 칸
소스
1

Array에서 마지막 값을 얻으려면 :

array_slice($arr,-1,1) ;

마지막 값 양식 배열 제거 :

array_slice($arr,0,count($arr)-1) ;
— 리 샤브
소스
1
array_slice($arr,-1,1)마지막 요소가 아닌 길이가 1 인 다른 배열이
— Vic
예를 들어 보자 : $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); 결과 :Array ( [0] => brown )
— Rishabh
1

간단히: $last_element = end((array_values($array)))

배열을 재설정하지 않으며 STRICT 경고를 제공하지 않습니다.

추신. 가장 많이 투표 된 답변은 여전히 ​​괄호가 아니므로이 답변을 제출했습니다.

— 다안
소스
1

나는 이것이 기존의 모든 대답에서 약간의 개선이라고 생각합니다.

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;
  • , 특히 대형 어레이에서 보다 나은 성능 end()또는 솔루션 사용array_keys()
  • 배열의 내부 포인터를 수정하지 않습니다
  • 빈 배열에 대해 정의되지 않은 오프셋에 액세스하려고 시도하지 않습니다
  • 빈 배열, 인덱스 배열, 혼합 배열 및 연관 배열에 대해 예상대로 작동합니다.
— 아델 마르
소스
슬프게도 슬라이스의 단일 항목에 명명 된 키가있을 수 있기 때문에 연관 배열에서는 작동하지 않습니다.
— Gras Double
당신은 맞습니다, 수정을 추가하기 위해 편집했습니다 ( array_values단일 요소 조각에)
— Adelmar
1

요즘에는 php.net/end answer 에서 제안한 것처럼 항상이 도우미를 선호합니다 .

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

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

이렇게하면 항상 포인터가 그대로 유지되며 괄호, 엄격한 표준 또는 기타 사항에 대해 걱정할 필요가 없습니다.

— 지오바니
소스
이미 위에서 언급 한 : stackoverflow.com/a/45333947/1255289
— miken32
-1

배열의 루프 내부에서 배열의 마지막 요소를 얻으려면 어떻게해야합니까?

아래 코드는 무한 루프를 발생시킵니다.

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
 }
}
— 바딤 포드 레브 스키
소스
2
end () 및 reset () 함수에 대해 알고 있습니다. 내 의견은 foreach와 같은 루프와 관련이 있거나 reset 함수는 반복을 위해 루프에 사용되는 배열의 내부 포인터를 재설정하기 때문에 이러한 함수를 사용할 수없는 동안 관련되었습니다. 죄송합니다. 질문이 더 간단했습니다. 프로젝트에서 더 발전된 상황을 원했습니다. 친애하는.
— Vadim Podlevsky 2012 년
이것은 여러면에서 잘못되었습니다 (중복이있는 배열, 엄격하지 않은 비교 ...). 어쨌든 질문과 실제로 관련이 없습니다.
— Tgr
end ($ array) 함수를 사용하여 마지막 요소를 얻으십시오. 왜 불필요한 루프를 사용합니까?
— Mahak Choudhary
1
@MahakChoudhary 내 의견은 "이 배열의 루프 내부에서 이미 일부 조작을 수행하는 경우 배열의 마지막 요소를 얻는 방법입니다. end ()를 사용하면 innver 포인터가 재설정되고 반복 루프가 끊어집니다. 건배!
— Vadim Podlevsky
-1 
$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;
}
— 허쉬 보라 드
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.