Иногда нужно работать с диапазоном элементов массива. Например, нужно обрабатывать большой кусок массива или упорядочить массив, а затем извлечь из него "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() с индексированными и ассоциированными массивами.
• Сохранять оригинальные индексы при работе с индексированными массивами.
• Извлекать все элементы до конца оригинального массива.

Если вы недостаточно знаете о массиве (вы не уверены, является ли первый ключ 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]; }

произведение извлечь (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:

Надеюсь, это будет полезно.