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

Programing

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

lottogame 2020. 2. 25. 22:01

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

확인,

에 대해 모두 알고 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

짧고 달다.

오류 메시지를 제거하고 한 줄짜리 양식과 효율적인 성능을 유지하는 솔루션을 생각해 냈습니다.

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

시험

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

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

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

옵션 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];( 제안 에 의해 미르코 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)]; ( 같은 제안 에 의해 콰지모도의 복제 , PHP 7.3 당 가능)

(언급 된 함수 : 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를 변경할 수 있습니다.

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

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

참조 별 통과 오류를 방지하는 한 가지 방법 (예 : "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))));

내부 포인터 수정에 관심이없는 경우 (인덱싱 및 연관 배열 모두 지원) :

// 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($value);
}

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

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

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

$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를 사용했습니다.

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 은이 문제를 직접 해결하기 위해 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 이상이 필요합니다.

이를 수행하고 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;

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

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

어때요?

current(array_slice($array, -1))

연관 배열에 사용
때 작동합니다 $array == [](반환 false)
원래 배열에 영향을 미치지 않습니다

end () 함수를 사용하십시오.

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

참고 : (PHP 7> = 7.3.0)의 경우 array_key_last — 배열의 마지막 키를 가져옵니다.

array_key_last ( array $array ) : mixed

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

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

array_slice($arr,-1,1) ;

마지막 값 양식 배열 제거 :

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

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

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

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

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

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

, 특히 대형 어레이에서 보다 나은 성능 end()또는 솔루션 사용array_keys()
배열의 내부 포인터를 수정하지 않습니다
빈 배열에 대해 정의되지 않은 오프셋에 액세스하려고 시도하지 않습니다
빈 배열, 인덱스 배열, 혼합 배열 및 연관 배열에 대해 예상대로 작동합니다.

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

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

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

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

$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');
echo ($array[count($array)-1]);

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

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

매우 간단

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

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

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

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

배열이있는 거의 모든 언어에서 실제로 A [A.size-1]로 잘못 될 수는 없습니다. 1 기반 배열 (0 기반이 아닌)이있는 언어의 예를 생각할 수 없습니다.

참고 URL : https://stackoverflow.com/questions/3687358/whats-the-best-way-to-get-the-last-element-of-an-array-without-deleting-it

'Programing' 카테고리의 다른 글

Math.Round (2.5)가 3 대신 2를 반환하는 이유는 무엇입니까? (0)	2020.02.25
Git에서 원격으로 브랜치 이름 바꾸기 (0)	2020.02.25
폴더에있는 모든 파일의 파일 이름 가져 오기 (0)	2020.02.25
통합 관리 파이프 라인 모드에 적용되지 않는 ASP.NET 설정이 감지되었습니다. (0)	2020.02.25
pip를 사용하여 Python 패키지를 다른 디렉토리에 설치 하시겠습니까? (0)	2020.02.25

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

복권의 역사, 로또 정보와 IT 기술 등을 다루는 블로그입니다.

행사, spring, 가족나들이, java, Javascript, 공연, 연극, Spring3, 관광, c#, JQuery, 극장순위, 뮤지컬, 무비순위, 축제, c++, 자바, 볼거리, 여행, 놀거리,

Today :
Yesterday :

lottogame

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

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

'Programing' 카테고리의 다른 글

'Programing'의 다른글

티스토리툴바

« 2025/02 »
일	월	화	수	목	금	토
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

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

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

'Programing' 카테고리의 다른 글

'Programing'의 다른글

관련글

티스토리툴바