У меня есть массив:
array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
Я хотел бы получить первый элемент этого массива. Ожидаемый результат: string apple
Одно требование: это невозможно сделать при передаче по ссылке, поэтому array_shift
не является хорошим решением.
Как я могу это сделать?
Оригинальный ответ, но дорогостоящий (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"
Если вы хотите получить ключ: (выполните его после reset)
echo key($arr); //echoes "4"
mixed reset (массив и массив $);
Описание:
reset() перематывает внутренний указатель массива на первый элемент и возвращает значение первого элемента массива, или FALSE, если массив пустой.
$first_value = reset($array); // First Element Value
$first_key = key($array); // First Element Key
Надеюсь, это поможет.:)
$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'
Если вы не хотите потерять текущую позицию указателя, просто создайте псевдоним для массива.
reset()
уже возвращает первый элемент, поэтому нет необходимости использовать current()
- echo reset($arr)
должно быть достаточно
current($array)
может получить первый элемент массива, согласно PHP Manual
Каждый массив имеет внутренний указатель на свой "текущий" элемент, который инициализируется первым элементом, вставленным в массив.
Так что это работает до тех пор, пока вы не переместите указатель массива, иначе вам придется сбросить массив.
current($array)
будет работать только в том случае, если указатель массива «в данный момент» указывает на первый элемент, в противном случае потребуется reset($array)
.
Вы можете получить элемент Nth с "конструкцией" языка:
// 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
- лучший вариант
list($first_value) = $my_array;
На мой взгляд, самый лучший вариант. У него нет проблем, связанных с другими ответами, представленными здесь: нет «перегиба», потому что он не копирует ни массив, ни создает новый. Нет «ссылок»: массив не изменен. Нет «сброса»: нет изменений во внутреннем указателе массива ...
PHP 5.4 +:
array_values($array)[0];
Предположим, что:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
Просто используйте:
$array[key($array)]
чтобы получить первый элемент или
key($array)
чтобы получить первый ключ.
Или вы можете отсоединить первый, если хотите его удалить.
current
?
Некоторые массивы не работают с такими функциями, как 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)
.
current()
не выдает ошибку, когда не передаются ссылки. При условии, что указатель все еще находится в начале, это работает.
В PHP 7.3 добавлены две функции для получения первого и последнего ключа массива напрямую без изменения исходного массива и без создания каких-либо временных объектов:
Помимо того, что они семантически значимы, эти функции даже не перемещают указатель массива (как это делает foreach
).
Имея ключи, можно получить значения по ключам напрямую.
$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) ];
От помощников 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;
}
Для записи, вот еще один мой ответ, для последнего элемента массива.
$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
because the each() function does not copy the entire array.
+1
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;
Вывод:
apple
Большинство из них работают! НО для быстрого однострочного (низкого ресурса) вызова:
$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/questions/1921421/get-the-first-element-of-an-array
current($array)
, который требует, чтобы внутренний указатель массива в любом случае был на первом элементе, и в этом случае echo reset($array)
является наиболее подходящим.
Ключковый способ:
$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
function get_first ($foo) {
foreach ($foo as $k=>$v){
return $v;
}
}
print get_first($foo);
reset()
как указатель массива сбрасывается до того, как foreach
все равно вызывается.
Держите это просто! Здесь много правильных ответов, но чтобы минимизировать путаницу. Эти два работают и уменьшают много накладных расходов.
key($array)
= получает первый ключ массива current($array)
= получает первое значение массива
current
равен текущему элементу. Вы должны сбросить указатель на начало массива, чтобы убедиться, что он действительно в начале.
Получить первый элемент:
array_values($arr)[0]
Получить последний элемент
array_reverse($arr)[0]
Это немного поздно для игры, но я столкнулся с проблемой, когда мой массив содержал элементы массива как дочерние элементы внутри него, и поэтому я не мог просто получить строковое представление первого элемента массива. С помощью функции 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]];
Использование:
$first = array_slice($array, 0, 1);
$val= $first[0];
По умолчанию array_slice
не сохраняет ключи, поэтому мы можем безопасно использовать нуль в качестве индекса.
Я думаю, что использовать array_values было бы лучше. Вы можете вернуть значение по индексу нуль из результата этой функции, чтобы получить "яблоко".
Это не простой ответ в реальном мире. Супость, что у нас есть примеры возможных ответов, которые вы можете найти в некоторых библиотеках.
$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
Никто не предложил использовать класс ArrayIterator:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'
обходит по ссылочному условию ФП.
Попробуй это:
$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";
Мне не нравится возиться с внутренним указателем массива, но также неэффективно создавать второй массив с 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. "Только переменные должны передаваться по ссылке". Если это так, almos все описанные здесь способы получат это сообщение... и некоторые из них используют много дополнительной памяти, дублирующей массив (или часть его). Легкий способ избежать этого - просто назначить значение inline перед вызовом любой из этих функций:
$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());
Таким образом, вы не получаете сообщение STRICT на экране ни в журналах, и вы не создаете никаких дополнительных массивов. Он работает с как индексированными, так и ассоциативными массивами
Также стоит иметь в виду контекст, в котором вы это делаете, поскольку исчерпывающая проверка может быть дорогостоящей и не всегда необходимой.
Например, это решение отлично подходит для ситуации, в которой я его использую (но, очевидно, во всех случаях нельзя полагаться...)
/**
* 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 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));
}
array(13, 'foo' => 'bar')
?
Мне нравится пример "списка", но "список" работает только с левой стороны задания. Если мы не хотим назначать переменную, мы будем вынуждены составлять временное имя, которое в лучшем случае загрязняет нашу область действия и в худшем случае перезаписывает существующее значение:
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, как если бы они были пропущенными, без каких-либо предупреждений или ошибок:
var_dump(call_user_func('reset', array_values(some_array())));
Небольшое изменение в том, что опубликовано в Sarfraz:
$array = array(1, 2, 3, 4, 5);
$output = array_slice($array, 0, 1);
print_r ($output);
Вы можете получить первый элемент, используя эту кодировку
$array_key_set = array_keys($array);
$first_element = $array[$array_key_set[0]];
Или использовать
$i=0;
foreach($array as $arr)
{
if($i==0)
{
$first_element=$arr;
break;
}
$i++;
}
echo $first_element;
foreach ($array as $arr) { $first_element = $arr; break; }
Ницца с комбинацией array_slice
и implode
:
$arr = array(1, 2, 3);
echo implode(array_slice($arr, 0, 1));
// Outputs 1
/*---------------------------------*/
$arr = array(
'key_1' => 'One',
'key_2' => 'Two',
'key_3' => 'Three',
);
echo implode(array_slice($arr, 0, 1));
// Outputs One
Используйте array_keys()
для доступа к ключам вашего ассоциативного массива в виде числового индексированного массива, который затем снова может использоваться как ключ для массива.
Когда решение arr[0]
:
(Обратите внимание, что поскольку массив с ключами является индексом на основе 0, 1-й элемент - индекс 0)
Вы можете использовать переменную, а затем вычесть ее, чтобы получить свою логику, 1 => 'apple'
.
$i = 1;
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[$i-1]];
Вывод:
apple
Ну, для простоты просто используйте:
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[0]];
Вывод:
apple
Первым методом является не только первый элемент, но может обрабатывать ассоциативный массив, как индексированный массив.
Слишком много ответов здесь, и выбранный ответ будет работать для большинства случаев. В моем случае у меня был 2D-массив, а array_values по какой-то нечетной причине - это удаление ключей на внутренних массивах. Итак, я в конечном итоге с этим
$keys = array_keys($myArray); // fetches all the keys
$firstElement = $myArray[$keys[0]]; // Get the first element using first key
Действительно плохое решение, но решение...: D
<?php
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
error_reporting(0);
$idx=0;
if(count($arr)>0){
while($idx!=-1)
{
if($arr[$idx]!=NULL)
{
echo $arr[$idx];
$idx=-1;
error_reporting(E_ALL);
}
else
{
$idx++;
}
}
}
?>
Поиск первого и последнего элементов в массиве
// get the first item in the array
print $array[0]; // prints 1
// get the last item in the array
print end($array);
&$array
качестве параметров.