Получить первый элемент массива

у меня есть массив:

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

Я хотел бы получить первый элемент этого массива. Ожидаемый результат: строка apple

одно требование: это не может быть сделано с прохождением по ссылке, так что array_shift не является хорошим решением.

как я могу это сделать?

30 ответов


оригинальный ответ, но дорогостоящий (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];

Как указал Майк (самый простой из возможных способов):

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

Если вы хотите получить ключ: (выполнить после сброса)

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

С документация PHP:

смешанные сброс (array &$array );

описание:

сброс() перематывает массива внутренний указатель на первый элемент и возвращает значение первого элемента массива, или 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'

Если вы не хотите потерять текущую позицию указателя, просто создайте псевдоним для массива.


Вы можете получить N-й элемент с языковой конструкцией "список":

// 1st item
list($firstItem) = $yourArray;

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

// 2nd item
list( , $secondItem) = $yourArray;

С функция array_keys вы можете сделать то же самое для кнопки:

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

current($array)

может получить первый элемент массива в соответствии с руководство по PHP

каждый массив имеет внутренний указатель на его "текущий" элемент, который инициализируется первый элемент вставлен в массив.

поэтому он работает, пока вы не переместите указатель массива, иначе вам придется сбросить массив.


PHP 5.4+:

array_values($array)[0];

допустим:

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

просто:

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

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

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

Это гораздо эффективнее, чем array_values(), потому что


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

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

С фреймворк 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;
}

а угловатые образом:

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

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

print get_first($foo);

сохранить это просто! Много правильных ответов, но, чтобы свести к минимуму все путаницы. Эти два работают и уменьшают большие накладные расходы.

key($array) = получает первый ключ массива
current($array) = получает первое значение массива


получить первый элемент:

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 будет вашим лучшим выбором здесь. Вы можете вернуть значение с нулевым индексом из результата этой функции, чтобы получить "apple".


использование:

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

по умолчанию array_slice не сохраняет ключи, поэтому можно смело использовать ноль в качестве индекса.


PHP 7.3 добавлены две функции для получения первого и последнего ключа массива напрямую без модификации исходного массива и без создания каких-либо временных объектов:

помимо семантического значения, эти функции даже не перемещают указатель массива (как 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) ];

это немного поздно для игры, но мне была представлена проблема, когда мой массив содержал элементы массива как дети внутри него, и поэтому я не мог просто получить строковое представление первого элемента массива. By использование 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...
?>

спасибо всем текущим решениям, которые помогли мне получить этот ответ, я надеюсь, что это поможет кому-то когда-нибудь!


два решения для вас.

Решение 1 - Просто используйте ключ. Вы не сказали, что не можете его использовать. :)

<?php
// get 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 an reset in
// just to make sure that the array pointer is at first element
// also reset return the first element
// reset($myArray);

// return first key 
$firstKey = key($array); 

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

решение 3 - array_keys()

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

это не soo простой ответ в реальном мире. Предположим, что у нас есть примеры возможных ответов, которые вы можете найти в некоторых библиотеках.

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

Как вы можете видеть, у нас есть несколько решений "одной строки", которые хорошо работают в некоторых случаях, но не во всех.

на мой взгляд, у вас должен быть этот обработчик только с массивами.

теперь поговорим о производительности, предполагая, что у нас всегда есть массив, например:

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

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

array_shift является быстрее, что сброс, то есть быстрее, что [count () -1] и эти три быстрее, что array_values и array_slice


мне нравится пример "список", но" список " работает только в левой части задания. Если мы не хотим назначать переменную, мы будем вынуждены составить временное имя, которое в лучшем случае загрязняет нашу область и в худшем случае перезаписывает существующее значение:

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

выше будет перезаписано любое существующее значение $x, и переменная $x будет висеть до тех пор, пока эта область активна (конец этой функции/метода или навсегда, если мы находимся на верхнем уровне). Это может быть работал с помощью call_user_func и анонимной функции, но это неуклюжий:

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

если мы используем анонимные функции, как это, мы можем на самом деле уйти с reset и array_shift, даже если они используют pass-by-reference. Это связано с тем, что вызов функции свяжет ее аргументы, и эти аргументы могут быть переданы по ссылке:

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

однако это на самом деле перебор, так как call_user_func будет выполнять это временное назначение внутри. Это позволяет нам относитесь к функциям pass-by-reference так, как если бы они были pass-by-value, без каких-либо предупреждений или ошибок:

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

также стоит иметь в виду контекст, в котором вы это делаете, поскольку исчерпывающая проверка может быть дорогостоящей и не всегда необходимой.

например, это решение отлично работает для ситуации, в которой я его использую (но, очевидно, нельзя полагаться во всех случаях...)

 /**
 * 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));
}

небольшое изменение в том, что опубликовал Sarfraz:

$array = array(1, 2, 3, 4, 5);
$output = array_slice($array, 0, 1);
print_r ($output);

старый пост, но в любом случае... Я предполагаю, что автор просто искал способ получить первый элемент массива после его получения из некоторой функции (например, mysql_fetch_row) без генерации строгих "только переменные должны передаваться по ссылке". Если это так, то почти все способы, описанные здесь, получат это сообщение... и некоторые из них используют много дополнительной памяти, дублирующей массив (или его часть). Простой способ избежать этого - просто назначить значение inline перед вызовом любого из эти функции:

$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());

таким образом, вы не получаете строгое сообщение на экране ни в журналах, ни в дополнительных массивах. Он работает с как индексированные, так и ассоциативные массивы


мне не нравится возиться с внутренним указателем массива, но также неэффективно создавать второй массив с array_keys() или array_values(), поэтому я обычно определяю это:

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