Php ассоциативный массив первый элемент. Извлечение элементов из массива с помощью array_slice(). Обычное удаление элементов - unset

Массивы очень широко применяются в 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.

произведение извлечь (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, за этот способ.

Если вы еще знаете способы получения первого элемента - пишите в комментариях.

Была ли эта статья полезна?

из первое (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]; }