Массивы 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 на массиве: удалить элемент, изменить или добавить - требуют от программиста дополнительных действий. Можно все оставить, как есть, и получится, как всегда. Можно учитывать каждую операцию на данных и фиксировать ее в полном объеме, создавать и хранить историю операций.
Это будет совсем другой уровень работы и кардинально лучшее качество результата.
Иногда нужно работать с диапазоном элементов массива. Например, нужно обрабатывать большой кусок массива или упорядочить массив, а затем извлечь из него "10 первых" значений от начала массива.
В данном уроке разбирается функция PHP array_slice() , с помощью которой можно извлечь диапазон элементов из массива.
Основы использования array_slice()
В функцию array_slice() передаются следующие аргументы:
- Массив, из которого будет извлекаться часть элементов.
- Позиция, с которой начинается извлекаемая часть массива (отсчёт элементов в массиве начинается с 0).
- Количесвто элементов/, которые надо извлечь из массива.
Array_slice() возвращает массив, который содержит извлечённые элементы. Оригинальный массив остаётся без изменений.
Пример использования функции array_slice() :
$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Выводит "Array ( => Stanley Kubrick => Martin Scorsese)" print_r(array_slice($directors, 1, 2));
В выше приведённом коде создаётся массив с 4-мя элементами (имена режиссёров), затем используется функция array_slice() для извлечения второго и третьего элементов.
Заметьте, что позиция элемента в массиве и его индекс не всегда одно и тоже. Например, первый элемент массива всегда имеет позицию 0 , но его индекс может быть 456 . Индексированные массивы PHP не обязаны иметь последовательные индексы, начинающиеся с ноля (хотя очень часто разработчики устанавливают именно такую нумерацию индекса).
Сохранение индексов
В выше приведённом примере можно заметить, что array_slice() изменила индексы элементов в возвращаемом массиве: Stanley Kubrick получил индекс 0 , а Martin Scorsese получил индекс 1 . Часто такое функционирование не вызывает никаких проблем, так как важен порядок следования элементов в получаемом массиве, а не их индексы.
Однако, иногда важно сохранять индексы извлекаемых элементов. Например, индексы могут быть ключами, с помощью которых указываются записи в таблице данных, или они могут быть важными для каких-то других целей. В таком случае вы можете сохранить индексы извлекаемых элементов с помощью передачи в качестве четвёртого аргумента значения true в функцию array_slice() . Например:
$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Выводит "Array ( => Stanley Kubrick => Martin Scorsese)" print_r(array_slice($directors, 1, 2, true));
Заметьте, что функция array_slice() в данном случае сохранили индексы оригинального массива для элементов: 1 для Stanley Kubrick , и 2 для Martin Scorsese .
Функция array_slice() всегда сохраняет индексы в ассоциированных массивах. Таким образом нет необходимости передавать значение true в качестве четвёртого аргумента при работе с ассоциированными массивами.
Извлечение элементов до конца массива
Если вы не будете указывать третий аргумент функции array_slice() , то в массив -результат попадут все элементы оригинального массива, начиная со стартовой позиции до конца массива. Такое функционирование может быть удобно в случае, если вы не знаете размеров оригинального массива. Например:
$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Выводит "Array ( => Stanley Kubrick => Martin Scorsese => Fritz Lang)" print_r(array_slice($directors, 1));
Использование функции array_slice() для ассоциированных массивов
вы можете использовать array_slice() для извлечения элементов из ассоциированного массива. Ниже приведён пример извлечения 2 элементов из ассоциированного массива, начиная со второго элемента:
$movie = array("title" => "Rear Window", "director" => "Alfred Hitchcock", "year" => 1954, "minutes" => 112); // Выводит "Array ( => Alfred Hitchcock => 1954)" print_r(array_slice($movie, 1, 2));
Заметьте, что функция array_slice() сохранила индексы "director" и "year" в массиве-результате.
Резюме
В данной статье мы разобрали использование функции array_slice() . Полезной PHP функции, которая возвращает диапазон элементов массива. Вы узнали:
- Как использовать функцию array_slice() с индексированными и ассоциированными массивами.
- Сохранять оригинальные индексы при работе с индексированными массивами.
- Извлекать все элементы до конца оригинального массива.
произведение извлечь (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");
Массивы очень широко применяются в PHP-скриптах.
Массив - это набор элементов, к каждому из которых можно обратиться по индексу или имени. Все массивы в PHP являются ассоциативными, т.е. остоят из пар "ключ"="значение".
Массив $arr содержит одну пару значений. Ключом в ней будет значение "car", а значением - "Чайка".
Значение ключей может быть текстового или числового типа, причем в одном массиве допускается применение ключей разных типов. Например, следующий код вполне работоспособен:
Иногда нет необходимости задавать ключи элементов. В этом случае можно воспользоваться тем, что PHP может создавать ключи автоматически при добавлении элементов в массив. Ключи всегда будут числовыми и начинаться с нуля. Например:
"первый", 1=>"второй", 2=>"третий"); ?>
Сочетание "=>" используется для отделения ключа от значения в элементе при объявлении массива.
Обращение к отдельному элементу массива производится по его индексу или ключу:
А с помощью конструкции foreach можно быстро перебрать все элементы массива:
$value) echo "Элемент массива номер $key равен "$value""; ?>
Для работы с архивами в PHP предусмотрен ряд функций, позволяющих выполнить набор стандартных операций, таких как сортировка, поиск или разворот массива. Рассмотрим наиболее используемые функции.
| array_chunk() | Служит для разделения массива на части заданного размера. Функция возвращает массив из фрагментов исходного массива. |
| array_combine() | Функция объединяет два массива так, что элементы первого становятся ключами, а элементы второрого - значениями результирующего ассоциативного массива. "а", 1=>"б", 2=>"в" ?> |
| array_count_values() | Подсчитывает количество уникальных значений в массиве и частоту их появления 3, "б" => 1, "в" => 2 ?> |
| array_diff() | Функция выделяет разницу двух массивов, т.е. элементы, которые есть в первом массиве и нет во втором. |
| array_fill() | Заполняет массив заданным значением "xxx" 3=>"xxx" 4=>"xxx" ?> |
| array_flip() | Меняет местами ключи и значения ассоциативного массива "а", 1=>"б", 2=>"в"); $res = array_flip($arr); // $res содержит "а"=>0, "б"=>1, "в"=>2 ?> |
| array_intersect() | Функция вычисляет пересечение двух массивов, т.е. выдаёт все элементы, которые есть одновременно в обоих массивах. |
| array_key_exists() | Функция проверяет, имеется ли в массиве ключ с таким именем. "а", 1=>"б", 2=>"в"); if(array_key_exists(1, $arr) echo "Ключ найден"; else echo "Ключ не найден"; ?> |
| array_keys() | Возвращает массив ключей "а", 1=>"б", 2=>"в"); $res = array_keys($arr); // $res содержит 0, 1, 2 ?> |
| array_merge() | Объединяет один или более массивов. Значения элементов с одинаковыми ключами заменяется элементами второго массива "а", 1=>"а", 2=>"в"); $arr2 = array(3=>"а", 0=>"б", 4=>"в"); $res = array_merge($arr1, $arr2); // $res содержит 0=>"б", 1=>"а", 2=>"в", 3=>"а", 4=>"в" ?> |
| array_rand() | Возвращает один случайный элемент из массива |
| array_reverse() | Возвращает исходный массив, но в обратном поряде, т.е. прочитанный от конца к началу. |
| array_search() | Функция производит поиск элемента массива, соответствующего заданным условиям. Возвращает имя соответствующего ключа. "а", 22=>"б", 33=>"в"); $key = array_search("б", $arr); // $key равен 22 ?> |
| array_shift() | Сдвигает все элементы массива к началу, при этом первый элемент массива теряется. |
| array_slice() | Извлекает фрагмент массива |
| array_sum() | Функция возвращает сумму всех значений массива |
| array_unique() | Удаляет повторяющиеся значения из массива |
| array_unshift() | Функция обратная array_shift(), сдвигает все элементы к концу массива и добавляет элемент в начало. |
| array_values() | Возвращает массив значений исходного массива "а", "y"=>"б", "z"=>"в"); $res = array_values($arr); // $res содержит "а", "б", "в" ?> |
| array() | Функция создаёт пустой или предустановленный массив. "а", "y"=>"б", "z"=>"в"); ?> |
| count() | Подсчитывает количество элементов в массиве |
| in_array() | Проверяет, существует ли в массиве указанное значение |
| list() | Оператор позволяет присвоить массив списку переменных. |
| sort() | Функция сортировки массива |
Как видите пользоваться массивами очень просто, а главное - чрезвычайно удобно. Ни один большой проект не обходится без применения массивов. Мы расмотрели только часть доступных функций, не вдаваясь в тонкости их применения для различных ситуаций. Более подробную информацию вы сможете почерпнуть из официального руководства на сайте www.php.net.
из первое (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:
Надеюсь, это будет полезно.