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

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

Надеюсь это поможет. 🙂

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

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

Вы можете получить элемент 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); 

просто current($array) может решить

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() потому что each() функция each() не копирует весь массив.

Для получения дополнительной информации см. http://www.php.net/manual/en/function.each.php

Большинство из них работают! НО для быстрого вызова одной строки (низкий ресурс):

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

Ключковый путь:

 $foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); function get_first ($foo) { foreach ($foo as $k=>$v){ return $v; } } print get_first($foo); 

 $myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum'); $arrayKeys = array_keys($myArray); // the first element of your array is: echo $myArray[$arrayKeys[0]]; 

Из помощников Ларавеля :

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

Это немного поздно для игры, но мне была предложена проблема, когда в моем массиве содержались элементы массива как дочерние элементы внутри него, и поэтому я не мог просто получить строковое представление первого элемента массива. Используя функцию current() PHP , мне удалось:

 <?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($arr)[0] 

Получить последний элемент

 array_reverse($arr)[0] 

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

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

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

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

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

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

Решение 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]]; 

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

 $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, как если бы они были пропущенными, без каких-либо предупреждений или ошибок:

 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 - ie associative<br/> * or<br/> * 2) All the keys are numeric - ie 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)); } 

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

Когда решение arr[0] :

(Обратите внимание, что поскольку массив с ключами является индексом на основе 0, первым элементом является индекс 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 

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

Мне не нравится возиться с внутренним указателем массива, но также неэффективно строить второй массив с 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 на экране ни в журналах, и вы не создаете никаких дополнительных массивов. Он работает как с индексированными, так и с ассоциативными массивами

Nice с комбинацией array_slice и array_slice :

 $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