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

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

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

Я хотел бы получить первый элемент этого массива. Ожидаемый результат: строка 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"

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

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'

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

current($array)может получить первый элемент массива, согласно руководству по PHP .

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

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

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

// First item
list($firstItem) = $yourArray;

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

// Second item
list( , $secondItem) = $yourArray;

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

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

PHP 5.4+:

array_values($array)[0];

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

Предположим, что:

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

От помощников Ларавела :

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)получает первое значение массива

РЕДАКТИРОВАТЬ:
Относительно комментариев ниже. Следующий пример выведет:string(13) "PHP code test"

$array = array
(
   '1'           => 'PHP code test',  
   'foo'         => 'bar', 5 , 5 => 89009, 
   'case'        => 'Random Stuff: '.rand(100,999),
   'PHP Version' => phpversion(),
   0             => 'ending text here'
);

var_dump(current($array));

Просто сделайте:

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

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

Хотя это работает, и прилично хорошо, пожалуйста, смотрите мой дополнительный ответ: https://stackoverflow.com/a/48410351/1804013

Я думаю, что использование array_values будет вашим лучшим выбором. Вы можете вернуть значение с нулевым индексом из результата этой функции, чтобы получить «яблоко».

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

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

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

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

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

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

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

<?php
    // Get the 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 a reset in just to make sure
    // that the array pointer is at the first element.
    // Also, reset returns the first element.
    // reset($myArray);

    // Return the 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быстрее reset, то есть быстрее, чем [count () - 1], и эти три быстрее, чем array_valuesи array_slice.

Я предполагаю, что автор просто искал способ получить первый элемент массива после получения его от какой-либо функции ( например , mysql_fetch_row ) без генерации STRICT «Только переменные должны передаваться по ссылке».

Если это так, то почти все способы, описанные здесь, получат это сообщение ... и некоторые из них используют много дополнительной памяти, дублирующей массив (или некоторую его часть). Простой способ избежать этого - просто присвоить значение 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 ни на экране, ни в журналах, ни создаваете дополнительные массивы. Он работает как с индексированными, так и с ассоциативными массивами.

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

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

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

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

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

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

Небольшое изменение в том, что написал Сарфраз:

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

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

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

Попробуй это:

$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";