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

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

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

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

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

От Документация по PHP:

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'

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

current($array)

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

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

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

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

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

В 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) ];

От помощников 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

$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

Ключковый способ:

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

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

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

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;

Ницца с комбинацией 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);