배열의 첫 번째 요소 가져 오기

배열의 첫 번째 요소 가져 오기

---

배열이 있습니다.

array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )

이 배열의 첫 번째 요소를 얻고 싶습니다. 예상 결과 : 문자열 apple

한 요구 사항 : 참조에 의해 전달 수행 할 수 없습니다 때문에, array_shift좋은 솔루션이 아닙니다.

어떻게 할 수 있습니까?

---

원래 답변이지만 비용이 많이 듭니다 (O (n)) :

array_shift(array_values($array));

O (1)에서 :

array_pop(array_reverse($array));

기타 사용 사례 등

의 수정 (배열 포인터 재설정의 의미에서)이 $array문제가되지 않는 경우 다음을 사용할 수 있습니다.

reset($array);

배열 "복사"가 필요한 경우 이론적으로 더 효율적이어야합니다.

array_shift(array_slice($array, 0, 1));

PHP 5.4 이상 (비어 있으면 색인 오류가 발생할 수 있음) :

array_values($array)[0];

---

Mike가 지적했듯이 (가능한 가장 쉬운 방법) :

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
echo reset($arr); // Echoes "apple"

키를 얻으려면 : (재설정 후 실행)

echo key($arr); // Echoes "4"

에서 PHP의 설명서 :

혼합 재설정 (어레이 & $ array );

기술:

reset ()은 배열의 내부 포인터를 첫 번째 요소로 되 감고 첫 번째 배열 요소의 값을 반환하거나 배열이 비어 있으면 FALSE를 반환합니다.

---

$first_value = reset($array); // First element's value
$first_key = key($array); // First element's key

---

$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'

현재 포인터 위치를 잃지 않으려면 배열에 대한 별칭을 만드십시오.

---

current($array)PHP 매뉴얼에 따르면 배열의 첫 번째 요소를 얻을 수 있습니다 .

모든 배열에는 배열에 삽입 된 첫 번째 요소로 초기화되는 "현재"요소에 대한 내부 포인터가 있습니다.

따라서 배열 포인터를 재배치 할 때까지 작동하며 그렇지 않으면 배열을 재설정해야합니다.

---

언어 구성 "list"를 사용하여 N 번째 요소를 가져올 수 있습니다.

// First item
list($firstItem) = $yourArray;

// First item from an array that is returned from a function
list($firstItem) = functionThatReturnsArray();

// Second item
list( , $secondItem) = $yourArray;

이 array_keys기능을 사용하면 키에 대해 동일한 작업을 수행 할 수 있습니다.

list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);

---

PHP 5.4 이상 :

array_values($array)[0];

---

PHP 7.3 은 원래 배열을 수정하지 않고 임시 객체를 생성하지 않고 배열 의 첫 번째 키와 마지막 키를 직접 가져 오는 두 가지 함수를 추가했습니다 .

• array_key_first
• array_key_last

의미 론적으로 의미가있는 것 외에도 이러한 함수는 배열 포인터를 이동하지도 않습니다 foreach.

키가 있으면 키로 직접 값을 얻을 수 있습니다.

---

예제 (모두 PHP 7.3 이상 필요)

첫 번째 / 마지막 키 및 값 가져 오기 :

$my_array = ['IT', 'rules', 'the', 'world'];

$first_key = array_key_first($my_array);
$first_value = $my_array[$first_key];

$last_key = array_key_last($my_array);
$last_value = $my_array[$last_key];

배열이 비어있을 수 없다고 가정 하고 첫 번째 / 마지막 값을 한 줄로 가져옵니다 .

$first_value = $my_array[ array_key_first($my_array) ];

$last_value = $my_array[ array_key_last($my_array) ];

빈 배열의 기본값을 사용하여 첫 번째 / 마지막 값을 한 줄로 가져옵니다.

$first_value = empty($my_array) ? 'default' : $my_array[ array_key_first($my_array) ];

$last_value = empty($my_array) ? 'default' : $my_array[ array_key_last($my_array) ];

---

다음을 가정하십시오.

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

다음을 사용하십시오.

$array[key($array)]

첫 번째 요소를 얻거나

key($array)

첫 번째 키를 얻으려면.

또는 제거하려는 경우 첫 번째 링크를 해제 할 수 있습니다.

---

일부 배열은 list, reset또는 같은 함수에서 작동하지 않습니다 current. 예를 들어 부분적으로 ArrayIterator를 구현하는 "가짜"배열 일 수 있습니다.

배열에 관계없이 첫 번째 값을 가져 오려면 반복기를 단락시킬 수 있습니다.

foreach($array_with_unknown_keys as $value) break;

그러면 값을에서 사용할 수 있으며 $value첫 번째 반복 후에 루프가 중단됩니다. 이것은 잠재적으로 큰 배열을 array_unshift (array_values ​​($ arr))와 같은 함수에 복사하는 것보다 효율적입니다.

이 방법으로도 키를 잡을 수 있습니다.

foreach($array_with_unknown_keys as $key=>$value) break;

함수에서 이것을 호출하는 경우 간단히 일찍 반환하십시오.

function grab_first($arr) {
    foreach($arr as $value) return $value;
}

---

에서 Laravel의 도우미 :

function head($array)
{
    return reset($array);
}

값으로 함수에 전달되는 배열 인 reset () 은 배열 복사본의 내부 포인터에 영향을 미치며 원래 배열을 건드리지 않습니다 ( false배열이 비어 있으면 반환 됨 ).

사용 예 :

$data = ['foo', 'bar', 'baz'];

current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz

또한 여기에 대안이 있습니다. 그건 아주 소폭 빠르게,하지만 더 흥미 롭군요. 배열이 비어있는 경우 기본값을 쉽게 변경할 수 있습니다.

function head($array, $default = null)
{
    foreach ($array as $item) {
        return $item;
    }
    return $default;
}

---

기록 을 위해 배열의 마지막 요소에 대한 또 다른 대답이 있습니다.

---

간단하게 :

array_shift(array_slice($array,0,1));

---

나는 할 것이다 echo current($array).

---

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;

산출:

apple

---

$myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
$arrayKeys = array_keys($myArray);

// The first element of your array is:
echo $myArray[$arrayKeys[0]];

---

$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

$firstValue = each($array)[1];

이것은 함수가 전체 배열을 복사하지 array_values()않기 때문에 훨씬 더 효율적 each()입니다.

자세한 내용은 http://www.php.net/manual/en/function.each.php를 참조하십시오 .

---

kludgy 방법은 다음과 같습니다.

$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

function get_first ($foo) {
    foreach ($foo as $k=>$v){
        return $v;
    }
}

print get_first($foo);

---

첫 번째 요소 가져 오기 :

array_values($arr)[0]

마지막 요소 가져 오기

array_reverse($arr)[0]

---

이러한 작업의 대부분! 그러나 빠른 단일 회선 (낮은 리소스) 통화의 경우 :

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $array[key($array)];

// key($array) -> will return the first key (which is 4 in this example)

이것이 작동하고 괜찮지 만 내 추가 답변도 참조하십시오 : https://stackoverflow.com/a/48410351/1804013

---

여기서 array_values를 사용하는 것이 가장 좋은 방법 이라고 생각 합니다. 해당 함수의 결과에서 인덱스 0의 값을 반환하여 'apple'을 얻을 수 있습니다.

---

이것은 게임에 조금 늦었지만 내 배열에 배열 요소가 자식으로 포함되어있는 문제가 발생하여 첫 번째 배열 요소의 문자열 표현을 얻을 수 없었습니다. PHP의 current()기능 을 사용하여 다음을 관리했습니다.

<?php
    $original = array(4 => array('one', 'two'), 7 => array('three', 'four'));
    reset($original);  // to reset the internal array pointer...
    $first_element = current($original);  // get the current element...
?>

현재의 모든 솔루션 덕분에이 답변을 얻을 수 있었으므로 언젠가 누군가에게 도움이되기를 바랍니다.

---

사용하다:

$first = array_slice($array, 0, 1);  
$val= $first[0];

기본적으로 array_slice는 키를 보존하지 않으므로 인덱스로 0을 안전하게 사용할 수 있습니다.

---

당신을위한 두 가지 솔루션.

해결 방법 1-키를 사용하십시오. 당신은 그것을 사용할 수 없다고 말하지 않았습니다. :)

<?php
    // Get the first element of this array.
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Gets the first element by key
    $result = $array[4];

    // Expected result: string apple
    assert('$result === "apple" /* Expected result: string apple. */');
?>

솔루션 2-array_flip () + key ()

<?php
    // Get first element of this array. Expected result: string apple
    $array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

    // Turn values to keys
    $array = array_flip($array);

    // You might thrown a reset in just to make sure
    // that the array pointer is at the first element.
    // Also, reset returns the first element.
    // reset($myArray);

    // Return the first key
    $firstKey = key($array);

    assert('$firstKey === "apple" /* Expected result: string apple. */');
?>

솔루션 3-array_keys ()

echo $array[array_keys($array)[0]];

---

간단하게 유지하세요! 여기에는 많은 정답이 있지만 모든 혼동을 최소화하기 위해이 두 가지가 작동하고 많은 오버 헤드를 줄입니다.

key($array)배열의 첫 번째 키를
current($array)가져옵니다 . 배열 의 첫 번째 값을 가져옵니다.

---

이것은 현실 세계에서 그렇게 단순한 반응이 아닙니다. 일부 라이브러리에서 찾을 수있는 가능한 응답의 예가 있다고 가정합니다.

$array1 = array();
$array2 = array(1,2,3,4);
$array3 = array('hello'=>'world', 'foo'=>'bar');
$array4 = null;

var_dump('reset1', reset($array1));
var_dump('reset2', reset($array2));
var_dump('reset3', reset($array3));
var_dump('reset4', reset($array4)); // Warning

var_dump('array_shift1', array_shift($array1));
var_dump('array_shift2', array_shift($array2));
var_dump('array_shift3', array_shift($array3));
var_dump('array_shift4', array_shift($array4)); // Warning

var_dump('each1', each($array1));
var_dump('each2', each($array2));
var_dump('each3', each($array3));
var_dump('each4', each($array4)); // Warning

var_dump('array_values1', array_values($array1)[0]); // Notice
var_dump('array_values2', array_values($array2)[0]);
var_dump('array_values3', array_values($array3)[0]);
var_dump('array_values4', array_values($array4)[0]); // Warning

var_dump('array_slice1', array_slice($array1, 0, 1));
var_dump('array_slice2', array_slice($array2, 0, 1));
var_dump('array_slice3', array_slice($array3, 0, 1));
var_dump('array_slice4', array_slice($array4, 0, 1)); // Warning

list($elm) = $array1; // Notice
var_dump($elm);
list($elm) = $array2;
var_dump($elm);
list($elm) = $array3; // Notice
var_dump($elm);
list($elm) = $array4;
var_dump($elm);

보시다시피 일부 경우에는 잘 작동하지만 전부는 아닌 몇 가지 '한 줄'솔루션이 있습니다.

제 생각에는 배열에만 해당 핸들러가 있어야합니다.

Now talking about performance, assuming that we have always array, like this:

$elm = empty($array) ? null : ...($array);

...you would use without errors:
$array[count($array)-1];
array_shift
reset
array_values
array_slice

array_shift is faster than reset, that is more fast than [count()-1], and these three are faster than array_values and array_slice.

---

I like the "list" example, but "list" only works on the left-hand-side of an assignment. If we don't want to assign a variable, we would be forced to make up a temporary name, which at best pollutes our scope and at worst overwrites an existing value:

list($x) = some_array();
var_dump($x);

The above will overwrite any existing value of $x, and the $x variable will hang around as long as this scope is active (the end of this function/method, or forever if we're in the top-level). This can be worked around using call_user_func and an anonymous function, but it's clunky:

var_dump(call_user_func(function($arr) { list($x) = $arr; return $x; },
                        some_array()));

If we use anonymous functions like this, we can actually get away with reset and array_shift, even though they use pass-by-reference. This is because calling a function will bind its arguments, and these arguments can be passed by reference:

var_dump(call_user_func(function($arr) { return reset($arr); },
                        array_values(some_array())));

However, this is actually overkill, since call_user_func will perform this temporary assignment internally. This lets us treat pass-by-reference functions as if they were pass-by-value, without any warnings or errors:

var_dump(call_user_func('reset', array_values(some_array())));

---

I don't like fiddling with the array's internal pointer, but it's also inefficient to build a second array with array_keys() or array_values(), so I usually define this:

function array_first(array $f) {
    foreach ($f as $v) {
        return $v;
    }
    throw new Exception('array was empty');
}

---

Try this:

$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";

---

No one has suggested using the ArrayIterator class:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'

gets around the by reference stipulation of the OP.

---

Also worth bearing in mind is the context in which you're doing this, as an exhaustive check can be expensive and not always necessary.

For example, this solution works fine for the situation in which I'm using it (but obviously it can't be relied on in all cases...)

 /**
 * A quick and dirty way to determine whether the passed in array is associative or not, assuming that either:<br/>
 * <br/>
 * 1) All the keys are strings - i.e. associative<br/>
 * or<br/>
 * 2) All the keys are numeric - i.e. not associative<br/>
 *
 * @param array $objects
 * @return boolean
 */
private function isAssociativeArray(array $objects)
{
    // This isn't true in the general case, but it's a close enough (and quick) approximation for the context in
    // which we're using it.

    reset($objects);
    return count($objects) > 0 && is_string(key($objects));
}

참고URL : https://stackoverflow.com/questions/1921421/get-the-first-element-of-an-array