Получить первый элемент массива
У меня есть массив:
array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
Я хотел бы получить первый элемент этого массива. Ожидаемый результат: строка apple
Одно требование: это не может быть сделано с передачей по ссылке, поэтому array_shift не очень хорошее решение
Как я могу это сделать?
42 ответа
Оригинальный ответ, но дорогой (O(n)):
array_shift(array_values($array));
В O(1):
array_pop(array_reverse($array));
Отредактировано с предложениями от комментариев для других случаев использования и т. Д...
При изменении (в смысле сброса указателей массива) $array это не проблема, вы можете использовать:
reset($array);
Это должно быть теоретически более эффективно, если требуется массив "copy":
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:
смешанный сброс (массив и $ массив);
Описание:
reset () перематывает внутренний указатель массива на первый элемент и возвращает значение первого элемента массива, или FALSE, если массив пуст.
$first_value = reset($array); // First Element's Value
$first_key = key($array); // First Element's Key
Надеюсь это поможет.:)
current($array)
может получить первый элемент массива, согласно PHP Manual
Каждый массив имеет внутренний указатель на свой "текущий" элемент, который инициализируется первым элементом, вставленным в массив.
Так что это работает до тех пор, пока вы не переместите указатель массива, иначе вам придется сбросить массив.
$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'
Если вы не хотите терять текущую позицию указателя, просто создайте псевдоним для массива.
В 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) ];
Вы можете получить 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);
Некоторые массивы не работают с такими функциями, как 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 = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
Просто используйте:
$array[key($array)]
чтобы получить первый элемент или
key($array)
чтобы получить первый ключ.
Или вы можете отсоединить первый, если вы хотите удалить его.
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;
}
Держите это просто! Здесь много правильных ответов, но чтобы минимизировать путаницу. Эти два работают и уменьшают много накладных расходов.
key($array) = получает первый ключ массиваcurrent($array) = получает первое значение массива
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;
Выход:
apple
В PHP 7.3 добавлены две функции для получения первого и последнего ключа массива напрямую, без изменения исходного массива и без создания каких-либо временных объектов:
"Есть несколько способов предоставить эту функциональность для версий до PHP 7.3.0. Можно использовать array_keys(), но это может быть довольно неэффективно. Также можно использовать reset() и key(), но это может изменить указатель внутреннего массива. Эффективное решение, которое не изменяет указатель внутреннего массива, записанное как polyfill:"
<?php
if (!function_exists('array_key_first')) {
function array_key_first($arr) {
foreach($arr as $key => $unused) {
return $key;
}
return NULL;
}
}
if (!function_exists('array_key_last')) {
function array_key_last($arr) {
return array_key_first(array_reverse($arr, true));
}
}
?>
$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
Клудгый способ это:
$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)
Хотя это работает, и неплохо, пожалуйста, смотрите мой дополнительный ответ: /questions/47988879/poluchit-pervyij-element-massiva/47988920#47988920
Использование:
$first = array_slice($array, 0, 1);
$val= $first[0];
По умолчанию, array_slice не сохраняет ключи, поэтому мы можем безопасно использовать ноль в качестве индекса.
Это немного поздно для игры, но я столкнулся с проблемой, когда мой массив содержал элементы массива как дочерние элементы внутри него, и поэтому я не мог просто получить строковое представление первого элемента массива. Используя 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...
?>
Благодаря всем текущим решениям мне удалось получить этот ответ, надеюсь, это поможет кому-нибудь когда-нибудь!
Я думаю, что использование array_values будет вашим лучшим выбором. Вы можете вернуть значение с нулевым индексом из результата этой функции, чтобы получить "яблоко".
<?php
$arr = array(3 => "Apple", 5 => "Ball", 11 => "Cat");
echo array_values($arr)[0]; // Outputs: Apple
?>
Другой пример:
<?php
$arr = array(3 => "Apple", 5 => "Ball", 11 => "Cat");
echo current($arr); // Outputs: Apple
echo reset($arr); // Outputs: Apple
echo next($arr); // Outputs: Ball
echo current($arr); // Outputs: Ball
echo reset($arr); // Outputs: Apple
?>
Два решения для вас.
Решение 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]];
Никто не предложил использовать класс ArrayIterator:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'
обходит по ссылочному условию ФП.
Мне не нравится возиться с внутренним указателем массива, но также неэффективно создавать второй массив с array_keys() или же array_values()поэтому я обычно определяю это:
function array_first(array $f) {
foreach ($f as $v) {
return $v;
}
throw new Exception('array was empty');
}
Старый пост, но в любом случае... Я думаю, что автор просто искал способ получить первый элемент массива после получения его из какой-либо функции (например, mysql_fetch_row) без генерации STRICT "Только переменные должны передаваться по ссылке". Если это так, почти все способы, описанные здесь, получат это сообщение... и некоторые из них используют много дополнительной памяти, дублирующей массив (или некоторую его часть). Самый простой способ избежать этого - просто встроить значение перед вызовом любой из этих функций:
$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());
Таким образом, вы не получите сообщение STRICT на экране ни в журналах, ни в дополнительных массивах. Работает как с индексированными, так и с ассоциативными массивами
Это не совсем простой ответ в реальном мире. Супост, что у нас есть примеры возможных ответов, которые вы можете найти в некоторых библиотеках.
$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 быстрее, чем reset, то есть быстрее, чем [count()-1], и эти три быстрее, чем array_values и array_slice