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

<p>у меня есть массив: </p><p><code>array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )</code></p><p>я хотел бы получить первый элемент этого массива. ожидаемый результат: <i>строка</i> <code>apple</code> </p><p>одно требование:<em> это нельзя сделать с помощью передачи по ссылке </em>, поэтому <code>array\_shift</code> не является хорошим решением.</p><p>как я могу это сделать?</p>

<p>оригинальный ответ, но дорогой (o (n)):</p><pre><code>array\_shift(array\_values($array)); в o (1):array_pop(array_reverse($array)); </code></pre><p><strong> отредактировано с предложениями из комментариев для других случаев использования и т. д ... </strong></p><p>если изменение (в смысле сброса указателей массива) <code>$array не является проблемой, вы можете использовать:reset($array); </code></pre><p>это должно быть теоретически более эффективно, если нужен массив «copy»:</p><pre><code>array\_shift(array\_slice($array, 0, 1)); с php 5.4+ (но может вызвать ошибку индекса, если пусто):array_values($array)[0]; </code></pre>

<p>как указал майк (самый простой способ):</p><pre><code>$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ) echo reset($arr); //echoes "apple" </code></pre><p>если вы хотите получить ключ: (выполните его после сброса)</p><pre><code>echo key($arr); //echoes "4" from <a href="http://be2.php.net/reset">документация php :<blockquote> смешанный <strong>reset</strong> (массив & $ array</em>);</p> </blockquote><p>описание:</p><blockquote> <p><strong>reset ()</strong> перематывает <em>array's</em> внутренний указатель на первый элемент и возвращает значение первого элемента массива, или false, если массив пустой.</p> </blockquote>

<pre><code>$first_value = reset($array); // first element's value $first_key = key($array); // first element's key </code></pre><p>надеюсь это поможет. :)</p>

<pre><code>$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' ); echo reset($arr); // echoes 'apple' </code></pre><p>если вы не хотите терять текущую позицию указателя, просто создайте псевдоним для массива.</p>

<p><code>current($array)может получить первый элемент массива, согласно <a href="http://php.net/manual/en/function.current.php">php manual <blockquote> каждый массив имеет внутренний указатель на свой «текущий» элемент, который инициализируется первым элементом, вставленным в массив. </blockquote>так что это работает до тех пор, пока вы не переместите указатель массива, иначе вам придется сбросить массив.

вы можете получить n-й элемент с помощью языковой конструкции "список":// 1st item list($firstitem) = $yourarray; // 1st item from an array that is returned from function list($firstitem) = functionthatreturnsarray(); // 2nd item list( , $seconditem) = $yourarray; </code></pre><p>с функцией array\_keys вы можете сделать то же самое для ключей:</p><pre><code>list($firstkey) = array_keys($yourarray); list(, $secondkey) = array_keys($yourarray); </code></pre>

<p>php 5.4+:</p><pre><code>array\_values($array)[0]; 

предположим, что:$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); </code></pre><p>просто используйте:</p><pre><code>$array[key($array)] </code></pre><p>чтобы получить первый элемент или</p><pre><code>key($array) чтобы получить первый ключ.или вы можете отсоединить первый, если вы хотите удалить его.

некоторые массивы не работают с такими функциями, как list, reset или current. может быть, это «ложные» массивы - например, частично реализующие arrayiterator.если вы хотите получить первое значение независимо от массива, вы можете замкнуть итератор:foreach($array\_with\_unknown\_keys as $value) break; ваше значение будет доступно в $value</code>, и цикл прервется после первой итерации. это более эффективно, чем копирование потенциально большого массива в функцию, подобную array\_unshift (array\_values ($ arr)).вы также можете получить ключ таким образом:foreach($array\_with\_unknown\_keys as $key=>$value) break; </code></pre><p>если вы вызываете это из функции, просто вернитесь рано:</p><pre><code>function grab\_first($arr) { foreach($arr as $value) return $value; } </code></pre>

<p><strong>php 7.3</strong> добавлены две функции для получения первого и последнего ключа массива <em>напрямую</em> без изменения исходного массива и без создания каких-либо временных объектов:</p><ul> <li><strong> <a href="http://php.net/manual/en/function.array-key-first.php">array\_key\_first</a> </strong> </li> <li><strong> <a href="http://php.net/manual/en/function.array-key-last.php">array\_key\_last</a> </strong> </li> </ul><p>помимо того, что они семантически значимы, эти функции даже не перемещают указатель массива (как это сделает <code>foreach</code>). </p><p>имея ключи, можно получить значения по ключам напрямую.</p><hr><h2>примеры (все они требуют php 7.3+)</h2><h3>получение первого/последнего ключа и значения:</h3><pre><code>$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_shift(array_slice($array,0,1)); </code></pre>

<p>от ларавеллы <a href="https://github.com/laravel/framework/blob/master/src/illuminate/support/helpers.php">помощники</a> :</p><pre><code>function head($array) { return reset($array); } </code></pre><p>массив, передаваемый по значению в функцию, <a href="http://php.net/manual/en/function.reset.php">reset ()</a> влияет на внутренний указатель копии массива, он не касается исходного массива. (обратите внимание, он возвращает <code>false</code>, если массив пуст)</p><p>пример использования:</p><pre><code>$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; } для записи вот <a href="https://stackoverflow.com/questions/3687358/whats-the-best-way-to-get-the-last-element-of-an-array-without-deleting-it/45333947#45333947">другой мой ответ , для последнего элемента массива.

я бы сделал echo current($array)</code>. </p>

<pre><code>$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]; </code></pre><p>это намного эффективнее, чем <code>array\_values()</code>, потому что функция <code>each()</code> не копирует весь массив.</p><p>для получения дополнительной информации см. <a href="http://www.php.net/manual/en/function.each.php">http://www.php.net/manual/en/function.each.php</a> </p>

<pre><code>$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); foreach($arr as $first) break; echo $first; </code></pre><p>результат:</p><pre><code>apple </code></pre>

<p>клудгый способ это:</p><pre><code>$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); function get_first ($foo) { foreach ($foo as $k=>$v){ return $v; } } print get\_first($foo); 

<strong>большинство из этих работ! но для быстрого однострочного (низкого ресурса) вызова:</strong>$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) хотя это работает, и прилично хорошо, пожалуйста, смотрите мой дополнительный ответ: <a href="https://stackoverflow.com/a/48410351/1804013">https://stackoverflow.com/a/48410351/1804013 

получить первый элемент:array_values($arr)[0] </code></pre><p>получить последний элемент</p><pre><code>array\_reverse($arr)[0] 

держите это просто! здесь много правильных ответов, но чтобы минимизировать путаницу. эти два работают и уменьшают много накладных расходов.key($array)</code> = получает первый ключ массива<br/> <code>current($array) = получает первое значение массива

использование:$first = array\_slice($array, 0, 1); $val= $first[0]; по умолчанию array_slice не сохраняет ключи, поэтому мы можем безопасно использовать ноль в качестве индекса.

это немного поздно для игры, но я столкнулся с проблемой, когда мой массив содержал элементы массива как дочерние элементы внутри него, и поэтому я не мог просто получить строковое представление первого элемента массива. используя <a href="http://php.net/manual/en/function.current.php">функцию 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. */'); ?> </code></pre><p>решение 3 - array\_keys ()</p><pre><code>echo $array[array_keys($array)[0]]; </code></pre>

<p>я думаю, что использование <a href="http://php.net/manual/en/function.array-values.php">array\_values </a> будет вашим лучшим выбором здесь. вы можете вернуть значение с нулевым индексом из результата этой функции, чтобы получить «apple».</p>

<p>это не совсем простой ответ в реальном мире. супост, что у нас есть примеры возможных ответов, которые вы можете найти в некоторых библиотеках. </p><pre><code>$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); </code></pre><p>как вы можете видеть, у нас есть несколько решений «одной линии», которые хорошо работают в некоторых случаях, но не во всех.</p><p>на мой взгляд, у вас должен быть этот обработчик только с массивами.</p><p>теперь поговорим о производительности, предполагая, что у нас всегда есть массив, например так:</p><pre><code>$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

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

<p>старый пост, но в любом случае ... я думаю, что автор просто искал способ получить первый элемент массива после получения его из какой-то функции (например, mysql\_fetch\_row) без генерации strict "только переменные должны передаваться по ссылке". если это так, почти все способы, описанные здесь, получат это сообщение ... и некоторые из них используют много дополнительной памяти, дублирующей массив (или некоторую его часть). самый простой способ избежать этого - просто встроить значение перед вызовом любой из этих функций:</p><pre><code>$first_item_of_array = current($tmp\_arr = mysql\_fetch\_row(...)); // or $first_item_of_array = reset($tmp\_arr = func\_get\_my\_huge\_array()); </code></pre><p>таким образом, вы не выводите сообщение strict на экран ни в журналы, ни в дополнительные массивы. работает с<strong> как индексированными, так и ассоциативными </strong>массивами</p>

<p>попробуй это:</p><p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false"> <div class="snippet-code"> <pre class="snippet-code-html lang-html prettyprint-override"><code>$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); echo reset($fruits)."\n";</code></pre> </div> </div> </p>

<p>небольшое изменение в том, что опубликовал сарфраз:</p><pre><code>$array = array(1, 2, 3, 4, 5); $output = array\_slice($array, 0, 1); print_r ($output); </code></pre>

<p>мне не нравится возиться с внутренним указателем массива, но также неэффективно создавать второй массив с <code>array\_keys()</code> или <code>array\_values()</code>, поэтому я обычно определяю это:</p><pre><code>function array\_first(array $f) { foreach ($f as $v) { return $v; } throw new exception('array was empty'); } </code></pre>

<p>мне нравится пример "списка", но "список" работает только в левой части задания. если мы не хотим назначать переменную, мы были бы вынуждены создать временное имя, которое в лучшем случае загрязняет нашу область видимости, а в худшем случае перезаписывает существующее значение:</p><pre><code>list($x) = some_array(); var_dump($x); </code></pre><p>выше будет перезаписывать любое существующее значение $ x, а переменная $ x будет зависать, пока эта область активна (конец этой функции/метода, или навсегда, если мы находимся на верхнем уровне). это можно обойти, используя call\_user\_func и анонимную функцию, но это неуклюже:</p><pre><code>var\_dump(call\_user\_func(function($arr) { list($x) = $arr; return $x; }, some\_array())); </code></pre><p>если мы будем использовать анонимные функции, подобные этой, мы сможем избежать перезагрузки и array\_shift, даже если они используют передачу по ссылке. это связано с тем, что вызов функции связывает ее аргументы, и эти аргументы можно передать по ссылке: </p><pre><code>var\_dump(call\_user\_func(function($arr) { return reset($arr); }, array\_values(some\_array()))); </code></pre><p>однако это на самом деле излишне, так как call\_user\_func выполнит это временное назначение внутри. это позволяет нам обрабатывать функции передачи по ссылке, как если бы они были передачей по значению, без каких-либо предупреждений или ошибок:</p><pre><code>var\_dump(call\_user\_func('reset', array\_values(some\_array()))); </code></pre>

<p>никто не предложил использовать класс arrayiterator:</p><pre><code>$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); $first\_element = (new arrayiterator($array))->current(); echo $first\_element; //'apple' </code></pre><p>обходит по ссылочному условию фп.</p>

<p>используйте<strong><code>array\_keys()</code></strong>для доступа к ключам вашего ассоциативного массива в виде числового индексированного массива, который затем снова можно использовать в качестве ключа для массива.</p><p><strong> когда решение <code>arr[0]</code> </strong>:</p><blockquote> <p>(обратите внимание, что, поскольку массив с ключами имеет индекс на основе 0, 1-й элемент имеет индекс 0)</p> </blockquote><p>вы можете использовать переменную и затем вычесть ее, чтобы получить свою логику, которая <code>1 => 'apple'</code>.</p><pre><code>$i = 1; $arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); echo $arr[array_keys($arr)[$i-1]]; <strong> результат: </strong>apple ну, для простоты - просто используйте:$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' ); echo $arr[array_keys($arr)[0]]; </code></pre><p><strong> результат: </strong></p><pre><code>apple </code></pre><p><strong> первым методом не только первый элемент, но и можно рассматривать ассоциативный массив как индексированный массив. </strong></p>

<p>хороший с комбинацией <code>array\_slice</code> и <code>implode</code>:</p><pre><code>$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 </code></pre>

<p>вы можете получить первый элемент, используя эту кодировку</p><pre><code>$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; </code></pre>