Элементов - Как получить первый элемент из ассоциативного массива PHP? Как получить первый элемент из ассоциативного массива PHP? Php ассоциативный массив первый элемент.
из первое (25)
У меня есть массив:
array(4 => "apple", 7 => "orange", 13 => "plum")
Я хотел бы получить первый элемент этого массива. Ожидаемый результат: струнное apple
Одно требование: это невозможно сделать с помощью ссылки , поэтому array_shift не является хорошим решением.
Как я могу это сделать?
Answers
Большинство из них работают! НО для быстрого вызова одной строки (низкий ресурс):
$array = array(4 => "apple", 7 => "orange", 13 => "plum"); echo $array; // key($array) -> will return the first key (which is 4 in this example)
Хотя это работает и прилично хорошо, пожалуйста, также см. Мой дополнительный ответ: https://stackoverflow.com/a/48410351/1804013
$first_value = reset($array); // First Element"s Value $first_key = key($array); // First Element"s Key
Надеюсь это поможет. :)
Старый пост, но в любом случае... Я предполагаю, что автор просто искал способ получить первый элемент массива после получения его из некоторой функции (например, 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 на экране ни в журналах, и вы не создаете никаких дополнительных массивов. Он работает как с индексированными, так и с ассоциативными массивами
может получить вам первый элемент массива, в соответствии с руководством PHP
Каждый массив имеет внутренний указатель на его «текущий» элемент, который инициализируется первым элементом, вставленным в массив.
Таким образом, он работает до тех пор, пока вы не переопределите указатель на массив, иначе вам придется сбросить массив.
Помимо того, что они имеют семантическую значимость, эти функции даже не перемещают указатель на массив (как это делал foreach).
Имея ключи, вы можете получить значения с помощью клавиш напрямую.
Примеры (все они требуют PHP 7.3+)
Получение первого / последнего ключа и значения:
$foo = array(4 => "apple", 7 => "orange", 13 => "plum"); function get_first ($foo) { foreach ($foo as $k=>$v){ return $v; } } print get_first($foo);Получение первого / последнего значения как однострочного, если предположить, что массив не может быть пустым :
$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) ];$arr = array(9 => "apple", 7 => "orange", 13 => "plum"); echo reset($arr); // echoes "apple"
Если вы не хотите потерять текущую позицию указателя, просто создайте псевдоним для массива.
Некоторые массивы не работают с такими функциями, как 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_keys() или array_values() , поэтому я обычно определяю это:
Function array_first(array $f) { foreach ($f as $v) { return $v; } throw new Exception("array was empty"); }
Получить первый элемент:
Array_values($arr)
Получить последний элемент
Array_reverse($arr)
$myArray = array (4 => "apple", 7 => "orange", 13 => "plum"); $arrayKeys = array_keys($myArray); // the first element of your array is: echo $myArray[$arrayKeys];
Вы можете получить элемент 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($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())));
Предположим, что:
$array = array(4 => "apple", 7 => "orange", 13 => "plum");
Просто используйте:
$array
для получения первого элемента или
Key($array)
чтобы получить первый ключ.
Или вы можете отсоединить первый, если хотите его удалить.
$array=array(4 => "apple", 7 => "orange", 13 => "plum"); $firstValue = each($array);
Это намного эффективнее, чем array_values() потому что each() функция 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; 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($array);
Это не простой ответ в реальном мире. Супость, что у нас есть примеры возможных ответов, которые вы можете найти в некоторых библиотеках.
$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)); // Notice var_dump("array_values2", array_values($array2)); var_dump("array_values3", array_values($array3)); var_dump("array_values4", array_values($array4)); // 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 ; array_shift reset array_values array_slice
array_shift быстрее, чем сброс, который быстрее, чем , и эти три быстрее, чем array_values и array_slice
Просто выполните:
Array_shift(array_slice($array,0,1));
Два решения для вас.
Решение 1. Просто используйте ключ. Вы не сказали, что не можете использовать его. :)
"apple", 7 => "orange", 13 => "plum"); // gets the first element by key $result = $array; //Expected result: string apple assert("$result === "apple" /* Expected result: string apple. */"); ?>
Решение 2 - array_flip () + key ()
"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;
Я бы сделал echo current($array) .
Использование:
$first = array_slice($array, 0, 1); $val= $first;
По умолчанию array_slice не сохраняет ключи, поэтому мы можем безопасно использовать нуль в качестве индекса.
ECMAScript5 (версия на Javascript) для работы с массивами.
forEach - Итерирует через каждый элемент массива и делает все, что вам нужно с каждым элементом.
["C", "D", "E"].forEach(function(element, index) { console.log(element + " is the #" + (index+1) + " in musical scale"); }); // Output // C is the #1 in musical scale // D is the #2 in musical scale // E is the #3 in musical scale
В случае, более заинтересованный в работе над массивом с использованием некоторой встроенной функции.
map - Создает новый массив с результатом функции обратного вызова. Этот метод хорош для использования, когда вам нужно отформатировать элементы вашего массива.
// Let"s upper case the items in the array ["bob", "joe", "jen"].map(function(elem) { return elem.toUpperCase(); }); // Output: ["BOB", "JOE", "JEN"]
уменьшить. Как видно из названия, он уменьшает массив до одного значения, вызывая передачу данной функции в элементе currenct и результате предыдущего выполнения.
Reduce(function(previous, current) { return previous + current; }); // Output: 10 // 1st iteration: previous=1, current=2 => result=3 // 2nd iteration: previous=3, current=3 => result=6 // 3rd iteration: previous=6, current=4 => result=10
each - Возвращает true или false, если все элементы массива проходят тест в функции обратного вызова.
// Check if everybody has 18 years old of more. var ages = ; ages.every(function(elem) { return elem >= 18; }); // Output: false
filter - очень похоже на каждый, кроме того, что фильтр возвращает массив с элементами, возвращающими true для данной функции.
// Finding the even numbers .filter(function(elem){ return (elem % 2 == 0) }); // Output:
Надеюсь, это будет полезно.
Если вы недостаточно знаете о массиве (вы не уверены, является ли первый ключ foo или bar), тогда массив также может быть, может быть, пустым .
Так что было бы лучше проверить, особенно если есть вероятность, что возвращаемое значение может быть логическим FALSE:
$value = empty($arr) ? $default: reset($arr);
Приведенный выше код использует reset и поэтому имеет побочные эффекты (он сбрасывает внутренний указатель массива), поэтому вы можете предпочесть использование array_slice для быстрого доступа к копии первого элемента массива:
$value = $default; foreach(array_slice($arr, 0, 1) as $value);
Предполагая, что вы хотите получить ключ и значение отдельно , вам нужно добавить четвертый параметр в array_slice:
Foreach(array_slice($arr, 0, 1, true) as $key => $value);
Чтобы получить первый элемент в виде пары (key => value):
$item = array_slice($arr, 0, 1, true);
Простая модификация для получения последнего элемента, ключа и значения отдельно:
Foreach(array_slice($arr, -1, 1, true) as $key => $value);
спектакль
Если массив не очень большой, вам на самом деле не нужен array_slice и вы можете получить копию всего массива ключей, а затем получить первый элемент:
$key = count($arr) ? array_keys($arr) : null;
Однако, если у вас очень большой массив, вызов array_keys потребует значительного времени и памяти больше, чем array_slice (обе функции обходят массив, но последняя завершает работу, как только array_slice требуемое количество элементов - то есть один),
Заметное исключение - когда у вас есть первый ключ, который указывает на очень большой и извилистый объект. В этом случае array_slice будет дублировать этот первый большой объект, а array_keys будет захватывать только ключи.
PHP 7.3
PHP 7.3 реализует array_key_first() а также array_key_last() . Они явно предоставлены для эффективного доступа к первому и последнему ключам без сброса внутреннего состояния массива в качестве побочного эффекта.
Таким образом, в PHP 7.3 к первому значению $array можно получить доступ с помощью
$array;
Вам все равно лучше проверить, что массив не пустой, иначе вы получите ошибку:
$firstKey = array_key_first($array); if (null === $firstKey) { $value = "Array is empty"; // An error should be handled here } else { $value = $array[$firstKey]; }
Массивы PHP используются повсеместно. Добавление и изменение значений, как правило, не вызывает затруднений.
Удаление элементов массива - особенная операция. Можно просто удалить элемент, а можно удалить и использовать. Этот нюанс дает большие возможности.
Массивы PHP
PHP - это современный язык программирования, функциональность в части работы с массивами выполнена на высоком уровне. Программист имеет возможность использовать обычные и ассоциативные массивы, проектировать многомерные структуры данных, иметь в качестве элементов массива значение любого типа.
Есть развитый набор функций по работе с массивами, специальные синтаксические конструкции. Имеется возможность обходить массив по своему алгоритму и назначать собственные функции обработки.
Примеры создания и использования массива
Функция scPrint - вспомогательная. Она рекурсивно записывает массив в строку символов для демонстрации получаемых результатов.
Массив $aFruits создается обычным образом: перечисляются значения, индексы назначаются автоматически с нуля. Последняя запятая не имеет значения и не приводит к созданию еще одного пустого элемента.
Массив $aData создается пустым, потом в него вносятся значения. Три - автоматом, а два - с ассоциативными индексами, которые не влияют на общую нумерацию значений. Так, элементы "слива" и "персик" имеют индексы "новая" и "свежий" соответственно.
Массив $aInfo - многомерный и ассоциативный.
Как в PHP-массиве удалить элемент, показывают три операции удаления.
Первая операция удаляет второй элемент из массива $aFruits, у него индекс равен 1. Следует отметить, что следующие за ним индексы не сдвигаются, значит, в циклических операциях с таким массивом следует предусмотреть проверку существования элемента.
Вторая операция - удаляет последний и первый элементы в массиве $aData, что подтверждает отсутствие влияния удаления на индексы и возможность одновременного удаления нескольких элементов.
Третья - удаляет массив в массиве и элемент в массиве, входящий в другой массив.
Обычное удаление элементов - unset
Функция unset удаляет. Неважно, что. Это может быть просто переменная или элемент массива. Считается, что unset() - это оператор языка, а не функция. Никакого значения этот оператор не возвращает, а то, что ему передано в качестве параметров, он «разрушает». Переменная или массив исчезают, как будто их не было.
На PHP удалить пустые элементы массива можно по-разному, собственно, что считать пустым элементом - зависит от программиста. Однако не слишком разумно использовать для этого несколько параметров в операторе unset(). Практичнее групповые операции выносить в групповые функции.
Современные компьютеры очень быстро работают, а PHP очень скор. Но это не повод создавать и обрабатывать тонны информации громоздкими алгоритмами, это объективное основание подойти к процессу удаления элементов массива прогрессивными способами.
Удаление элементов строчными методами
На PHP удалить пустые элементы массива можно оптом, преобразовав массив в строку и вернув его обратно. Но этот случай годится только для реально пустых элементов, пропущенных индексов или с целью переиндексации массива.
Понятие пустого элемента зависит от задачи. Часто пустым становится существующий элемент массива, в котором содержатся определенные сведения. Например, в массиве ведется учет посетителей. Элемент массива содержит:
- время прихода посетителя;
- текущий режим работы;
- активную страницу;
- время последнего действия.
Если разница между временем прихода и временем последнего действия составляет более 1 минуты (или иное значение), можно считать, что клиент покинул сайт. Записи о таких клиентах можно удалять, если стоит задача мониторить список активных посетителей и не использовать более совершенные методы с использованием JavaScript.
Однако «строчная» обработка хороша. Например, на PHP удалить повторяющиеся элементы массива можно так:
Быстрый и доступный способ. Необязательно использовать символы "[" и "]" для обозначения каждого элемента, но следует помнить, что, трансформируя массив в строку, нужно соблюсти требование уникальности каждого его элемента. Символы для обрамления следует выбирать с учетом символов, которые допустимы в элементе. Незыблемое правило: каждый элемент массива в строке уникален и имеет свое место (иначе ничего не вернуть обратно).
Этот способ удобнее, когда стоит задача на PHP удалить элемент массива по значению. Можно использовать функцию array_flip и поменять значения и ключи местами, потом сделать классический unset. Можно использовать функцию array_search и найти ключ значения, которое нужно удалить. Но строчный вариант решения нагляднее и проще.
PHP практически ни в чем не ограничивает разработчика: ни в количестве размерностей, ни в размерах элементов. Смысла увлекаться этим нет. Каждый элемент должен быть минимально возможной длины, а количество размерностей должно стремиться к единице.
Если количество размерностей массива более трех - это веское основание пересмотреть решение. Если элемент массива имеет длину более 4000-8000 символов, должны возникать сомнения в разумности построенной картины данных.
Это мнение вытекает не из контекста функциональности PHP-массива: удалить элемент, добавить объект другого типа, изменить что-то одно на что-то совсем другое. Простота - залог успеха не только в жизни, но и в алгоритме. Программа должна работать, а не удивлять своими размерностями, размерами и масштабами идей. Важен результат, а не грандиозная идея.
Как современный язык программирования PHP не проходит мимо рекурсии и стека. Принципиально неважно, что имеет в виду программист, когда использует функцию array_pop() в PHP: удалить последний элемент массива или просто получить его в какую-либо переменную.
Но следует иметь в виду, что в данном контексте функция array_pop - это из сферы push & pop, то есть это инструменты стека, а не удаления.
Здесь принято говорить не «удалить», а «извлечь». Семантика существенно отличается. Однако функция array_shift() в PHP: удалить первый элемент массива или извлечь его - имеет иной оттенок. Здесь также элемент извлекается во внешнюю переменную, и его не будет в массиве, но индексы смещаются.
При извлечении первого элемента из массива все следовавшие за ним элементы смещаются вперед, но изменяются только числовые индексы, строчные остаются неизменными.
Удалить или изменить: история операций
Переменная - это очень давнее прошлое, массив - это уже давно было, объект - это было вчера. Об объектно-ориентированном программировании еще пока только говорят, но ничего не используют в полную силу. Редкий случай, когда поверхностные решения стали предметом восторженных решений и «умудренных» массой «тела» систем управления сайтами (CMS).
Объективное правило: не в количестве кода все дело, а в его качестве! Но никакая современная CMS к этому правилу еще не прислушалась. Ее авторы считают, что они поступают правильно и знают, что делают.
Результат (характерная черта): ни одна из современных CMS не отличается приличной «фигурой» (стройностью и легкостью конструкций), все обладают необъятной полнотой кода, каждая требует к себе уважения:
- высокой квалификации программиста;
- нуждается в инсталляции;
- предъявляет требования к хостингу;
- создает трудности при переезде на другой хостинг;
- реально тормозит в работе и администрировании.
Программисты очень долго шли к понятию отката, современное программирование не мыслит создание программного обеспечения без двух функций:
- undo;
- redo.
Не только человеку свойственно ошибиться, но в любой ситуации откат должен быть. В современных средствах интернет-программирования по сей день этот момент не только не имеет значения, но и применяется в очень ограниченных масштабах.
Операции PHP на массиве: удалить элемент, изменить его тип или добавить что-то новое - понятны. Но раньше были переменные, потом массивы, затем объекты. Разве не повод задуматься о том, что массив - это просто переменная в течение времени?
Массив - это структура данных в течение времени. Ни один язык по сей день не рассматривает время как фактор синтаксиса. Про семантику можно даже не говорить: с древнейших времен по сей день программисты и пользователи понимают только файлы и папки. Максимум до чего дошло развитие, например, на PHP пространство имен (namespace) банально отражается на структуру папок и файлов.
В этом контексте банальные действия в PHP на массиве: удалить элемент, изменить или добавить - требуют от программиста дополнительных действий. Можно все оставить, как есть, и получится, как всегда. Можно учитывать каждую операцию на данных и фиксировать ее в полном объеме, создавать и хранить историю операций.
Это будет совсем другой уровень работы и кардинально лучшее качество результата.
произведение извлечь (12)
Если бы у меня был массив вроде:
$array["foo"] = 400; $array["bar"] = "xyz";
И я хотел получить первый элемент из этого массива, не зная ключа для него, как бы я это сделал? Есть ли функция для этого?
Answers
reset($array); $first = current($array);Я делаю это, чтобы получить первое и последнее значение. Это работает и с большим количеством значений.
$a = array("foo" => 400, "bar" => "xyz",); $first = current($a); //400 $last = end($a); //xyz
Просто чтобы у нас были другие варианты: reset($arr); достаточно хорошо, если вы не пытаетесь сохранить указатель массива на месте, и с очень большими массивами он несет минимальное количество накладных расходов. Тем не менее, есть некоторые проблемы:
$arr = array(1,2); current($arr); // 1 next($arr); // 2 current($arr); // 2 reset($arr); // 1 current($arr); // 1 !This was 2 before! We"ve changed the array"s pointer.
Способ сделать это без изменения указателя:
$arr; // OR reset(array_values($arr));
Выгода $arr; заключается в том, что он вызывает предупреждение, если массив фактически пуст.
Reset($array); list($key, $value) = each($array); echo "$key = $value\n";
Вы можете попробовать это.
Чтобы получить первое значение массива: -
"bar", "hello" => "world"); var_dump(current($large_array)); ?>
Чтобы получить первый ключ массива
"bar", "hello" => "world"); $large_array_keys = array_keys($large_array); var_dump(array_shift($large_array_keys)); ?>
Ты можешь сделать:
$values = array_values($array); echo $values;
Используйте функцию reset (), чтобы получить первый элемент из этого массива, не зная ключ для него следующим образом.
$value = array("foo" => 400, "bar" => "xyz"); echo reset($value);
выход // 400
Если вы не знаете достаточно о массиве (вы не знаете, является ли первый ключ foo или bar ), то массив может также быть, может быть, пустым .
Поэтому было бы лучше проверить, особенно если есть вероятность того, что возвращаемое значение может быть логическим FALSE:
$value = empty($arr) ? $default: reset($arr);
Вышеприведенный код использует reset и имеет побочные эффекты (он сбрасывает внутренний указатель массива), поэтому вы можете предпочесть использовать array_slice для быстрого доступа к копии первого элемента массива:
$value = $default; foreach(array_slice($arr, 0, 1) as $value);
Предполагая, что вы хотите получить как ключ, так и значение отдельно , вам нужно добавить четвертый параметр в array_slice:
Foreach(array_slice($arr, 0, 1, true) as $key => $value);
Чтобы получить первый элемент в виде пары (key => value):
$item = array_slice($arr, 0, 1, true);
Простая модификация для получения последнего элемента, ключа и значения отдельно:
Foreach(array_slice($arr, -1, 1, true) as $key => $value);
Вы можете добавить свой собственный обработчик ошибок, который может предоставить дополнительную информацию об отладке. Кроме того, вы можете настроить его для отправки по электронной почте.
Function ERR_HANDLER($errno ,$errstr, $errfile, $errline){
$msg="Someting bad happened. [$errno] $errstr
File: $errfile
Line: $errline
".json_encode(debug_backtrace(), JSON_PRETTY_PRINT)."
"; echo $msg; return false; } function EXC_HANDLER($exception){ ERR_HANDLER(0,$exception->getMessage(),$exception->getFile(),$exception->getLine()); } function shutDownFunction() { $error = error_get_last(); if ($error["type"] == 1) { ERR_HANDLER($error["type"],$error["message"],$error["file"],$error["line"]); } } set_error_handler ("ERR_HANDLER", E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED); register_shutdown_function("shutdownFunction"); set_exception_handler("EXC_HANDLER");
Итак, у нас есть массив $arr и нужно получить первый элемент этого массива.
Нельзя просто сделать так:
$first = $arr;
Элемент с индексом 0 может быть просто не определен. Например в случае если массив ассоциативный, либо мы сделали unset($arr) .
Способ 1
$first = reset($arr);Используя reset мы получаем первый элемент, однако есть один побочный эффект: указатель массива также сбрасывается на первый элемент. Хотя в принципе эта функция и предназначена для сброса указателя. Документация по функции reset () .
Обратите внимание: если массив пустой reset() вернет false , и этот результат будет неотличим от случая, когда массив не пустой, но содержит false в качестве первого элемента.
$a = array(); $b = array(false, true, true); var_dump(reset($a) === reset($b)); //bool(true)
Способ 2
Можно воспользоваться функцией array_shift - она извлекает первый элемент и при этом удаляет его из переданного массива. Документация по array_shift () .
$first = array_shift($arr);
Способ 3
Написать свою функцию для этих целей:
Function array_first($array, $default = null) { foreach ($array as $item) { return $item; } return $default; }
Преимущество в том, что она не меняет исходный массив. Также вы можете передать параметр $default , который будет использоваться в качестве значения по умолчанию, если массив пустой.
Кстати во фреймворке Laravel эта функция уже определена и позволяет указать еще и callback, в который можно передать условие. Можно например взять первый элемент, который больше 10 или первый элемент, который не является числом.
Вот код более совершенной функции:
Function array_first($array, callable $callback = null, $default = null) if (is_null($callback)) { if (empty($array)) { return $default instanceof Closure ? $default() : $default; } foreach ($array as $item) { return $item; } } foreach ($array as $key => $value) { if (call_user_func($callback, $value, $key)) { return $value; } } return $default instanceof Closure ? $default() : $default; }
Ее можно использовать например так:
$array = ; $first = array_first($array, function ($value, $key) { return $value >= 150; }); echo $first; // 200
Способ 4
Функция current () также пригодна для получения первого элемента массива.
Пример использования:
$transport = array("foot", "bike", "car", "plane"); $mode = current($transport); // $mode = "foot";
Точнее эта функция используется для возвращения элемента, на котором находится внутренний указатель массива. В большинстве случаев указатель на первом элементе, однако есть ситуации, когда может быть возвращен не первый элемент.
$transport = array("foot", "bike", "car", "plane"); next($transport); // перемещаем указатель вперед (http://php.net/manual/ru/function.next.php) $mode = current($transport); // $mode = "bike"; - т. е. вернулся уже второй элемент массива.
Спасибо комментатору Alexey Berlinskiy, за этот способ.
Если вы еще знаете способы получения первого элемента - пишите в комментариях.
Была ли эта статья полезна?
