Что принимает массив в качестве параметров php

Ранее мы рассмотрели, как в переменные можно сохранить одиночное значение, например, одно число или одну строку. Но кроме того, мы можем сохранить в переменную набор значений. И для этого используются массивы .

Есть несколько способов определения массивов. Первый способ представляет использование функции array() :

$numbers = array();

В данном случае определяется пустой массив $numbers .

Второй способ представляет использование квадратных скобок [] :

$numbers = [];

При определении массива мы сразу можем передать ему начальные данные. Если применяются квадратные скобки, то элементы массива передаются внутри скобок:

$numbers = [1, 2, 3, 4];

Аналогичное определение массива с помощью функции array() :

$numbers = array(1, 2, 3, 4);

В качестве элементов массива могут выступать объекты любого типа.

Для обращения к элементам массива применяются ключи . Ключ может представлять число или строку или одновременно и числа, и строки.

Для обычных массивов ключ представляет число. Числовые ключи еще называют индексами. Нумерация индексов начинается с нуля, то есть первый элемент массива имеет индекс 0, второй элемент — индекс 1 и так далее.

Например, обратимся к третьему элементу массива:

Поскольку нумерация индексов начинается с нуля, то чтобы обратиться к третьему элементу, надо использовать индекс 2.

Таким образом мы получаем значение элемента массива. Но также мы можем его изменить:

При этом нужно учитывать количество элементов массива. Так, мы не можем обратиться к элементу с несуществующим индексом:

В данном случае в массиве $numbers всего 4 элемента, поэтому индексом последнего элемента будет 3. Таким образом, элемента с индексом 4 в массиве не существует, и при попытке получить его значение echo $numbers[4] PHP нам покажет предупреждение.

Тем не менее если мы хотим установить элемент по еще не существующему индексу, мы можем это сделать:

Здесь устанавливается элемент с индексом 5. После установки мы можем получать его значение. При этом элемента с индексом 4 по прежнему не существует.

Для добавления нового элемента в массив мы можем, как в примере выше, просто установить новый элемент по еще не установленному индексу. Но есть и другой способ:

При таком способе новый элемент добавляется в конец массив, соответственно здесь, чтобы получить новый элемент, надо использовать индекс 4.

Чтобы получить полное наглядное представление о том, как в конкретном массиве сопоставляются ключи и значения элементов, можно использовать функцию print_r , в которую в качестве параметра передается массив:

Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

Также следует отметить, что необязательно как-то специально инициализровать переменную массива — мы можем по ходу добавлять элементы в массив:

 20 [1] => 120 [2] => 720 ) ?>

Оператор =>

Оператор => позволяет сопоставить ключ с определенным значением. Хотя при определении массива выше нам не требовался подобный оператор, тем не менее мы можем его применять. Например, следующий массив:

$numbers = [1, 4, 9, 16];

Будет аналогичен следующему массиву:

$numbers = [0=>1, 1=>4, 2=>9, 3=>16]; // $numbers = array(0=>1, 1=>4, 2=>9, 3=>16);

Каждый элемент определяется в следующем формате: ключ => значение

В дальнейшем мы также можем обращаться к элементам этого массива.

Этот оператор может понадобится, если мы хотим переопределить порядок индексов. Так, по умолчанию нумеация индексов начинается с нуля и каждый следующий элемент имеет индекс предыдущего элемента + 1. Оператор => же позволяет определить свои индексы вручную для элементов, необязательно с нуля и необязательно по порядку:

$numbers = [1=> 1, 2=> 4, 5=> 25, 4=> 16]; echo $numbers[2]; // 4

Также мы можем задать индекс лишь для одного элемента, тогда для последующих элементов индекс автоматически будет увеличиваться на единиицу:

$numbers = [4=> 16, 25, 36, 49, 64]; print_r($numbers);

В данном случае индексация начинается с числа 4 — это индекс элемента 16. Тогда для элемента 25 индексом будет число 5 и так далее.

Array ( [4] => 16 [5] => 25 [6] => 36 [7] => 49 [8] => 64 )

Перебор массива

Для перебора массива мы можем применять стандартный метод for :

В данном случае мы не определяем вручную индексы элементов, поэтому индексация начинается с нуля с увеличением на единиицу для последующего элемента. Поэтому мы можем в цикле через переменную $i передавать индекс, начиная с нуля. Единственная трудность может заключаться в том, как определить индекс конечного элемента, чтобы установить потолок для переменной $i . В этом случае мы можем с помощью встроенной функции count() получить длину массива. Эта функция в качестве параметра принимает массив и возвращает его длину.

Результат работы скрипта:

Tom Sam Bob Alice

Цикл foreach

Тем не менее выше использованный способ перебора не поможет, если индексы определяются вручную и отличаются они от соседних индексов не на единицу, а на произвольную величину. В этом случае мы можем использовать специальный цикл — foreach :

 "Tom", 4 => "Sam", 5 => "Bob", 21 => "Alice"]; foreach($users as $element) < echo "$element
"; > ?>

В цикле foreach из массива последовательно извлекаются все элементы, и их значение помещается в переменную, указанную после ключевого слова as . В данном случае в переменную $element по очереди помещаются все четыре значения из массива $users . Когда будет извлечен последний элемент из массива, цикл завершается.

В итоге мы получим тот же результат:

Tom Sam Bob Alice

Цикл foreach позволяет извлекать не только значения, но и ключи элементов:

 "Tom", 4 => "Sam", 5 => "Bob", 21 => "Alice"]; foreach($users as $key => $value) < echo "$key - $value
"; > ?>

Здесь при переборе элементов цикла в переменную $key будет передаваться ключ элемента, а в переменную $value — его значение.

Результат работы скрипта:

1 - Tom 4 - Sam 5 - Bob 21 - Alice

Массивы

— это коллекция переменных, индексированных и увязанных друг с другом в одну суперпеременную, обеспечивающую простой доступ и допускающую возможность ссылаться на нее, которая предоставляет удобный способ обмена сразу несколькими значениями между строками кода, функциями и даже страницами. В этой статье приведен обзор внутреннего устройства массивов и описаны все встроенные функции PHP, предназначенные для манипулирования массивами. Но прежде чем заняться углубленным изучением этой темы, целесообразно рассмотреть наиболее распространенные способы использования массивов в реальном коде PHP.

В виде массивов представлены многие встроенные переменные среды PHP (в качестве примера можно указать массив $_SESSION, который содержит все имена переменных и значения, распространяющиеся со страницы на страницу с помощью механизма сеансов PHP). Для того чтобы получить доступ к этим переменным, необходимо, как минимум, знать способы обращения к массивам.

Ассоциативные массивы и массивы с числовыми индексами

В массивах с числовыми индексами в качестве значений индексов используются числа, а в ассоциативных массивах – строки. В ассоциативных массивах каждому новому элементу нужно назначить уникальный строковый индекс. Массивы с числовыми индексами позволяют просто добавить элемент, а PHP автоматически назначит ему в качестве индекса первое свободное число начиная с 0. Массивы обоих типов позволяют добавлять новые элементы по одному. Ассоциативные массивы прекрасно подходят для сохранения информации о настройках, так как их ключи могут хранить смысловую информацию.

Будьте внимательны: большинство людей начинают счет не с 0, а с 1. По рассеянности вы легко можете обратиться к несуществующему элементу массива – это называется ошибкой завышения на единицу (off-by-one error). Чтобы получить значение индекса последнего элемента в массиве, нужно вычесть из длины массива единицу. Типичный симптом того, что по ошибке вы начали обходить массив с индекса 1, а не 0 – обнаружение того, что при попытке обратиться к последнему элементу массива такого элемента просто не находится.

Внутри PHP массивы с числовыми индексами хранятся точно так же, как и ассоциативные массивы. Массивы с числовыми индексами обеспечивают более простой способ обхода наборов данных, поскольку для доступа к следующему значению достаточно увеличить на единицу индекс предыдущего.

Создание массива

Для создания массивов в сценарии PHP предусмотрены три основных способа: присваивание значения одному из элементов будущего массива (и тем самым неявное создание массива), использование конструкции array() и вызов функции, особенностью которой является то, что она возвращает массив в качестве своего значения.

Непосредственное присваивание

Простейший способ создания массива состоит в выполнении с некоторой переменной таких действий, как будто эта переменная уже представляет собой массив, и присваивании ей значения:

// Создание и наполнение числового массива $array[0] = 1; $array[1] = 2; $array[3] = 'Hello, world!'; // Создание и наполнение ассоциативного массива $arr['fruit'] = 'яблоко'; $arr['color'] = 'зеленый'; $arr['count'] = 40; // Ассоциативные и числовые массивы можно перемешивать, это не // вызовет ошибки (но лучше такой подход не использовать) $arr[4] = 'груша'; $array['ten'] = 10;

Чтобы создать массив, нужно определить значения его элементов и индексов. В качестве элементов массива могут использоваться любые значения, включая строки, числа и даже другие массивы. Поле ключа должно быть скаляром. Скалярные значения – это такие значения элементарного типа, как числа или строки, включая значения TRUE и FALSE, но не данные, которые могут иметь несколько составных значений, например объекты. Кроме того, в поле ключа массива для каждого элемента должно быть уникальное значение, иначе вы можете записать новый элемент поверх уже имеющегося, с тем же ключом. Если вы попытаетесь назначить новому элементу ключ, который уже определен для другого элемента, новое значение просто заменит старое.

Конструкция array()

Еще один способ создания массива состоит в использовании конструкции array(), которая создает новый массив на основании спецификации элементов и ассоциированных с ними ключей. В своей простейшей версии конструкция array() вызывается без параметров, что приводит к созданию нового пустого массива. Более сложной по сравнению с простейшей является версия, в которой конструкция array() принимает разделенный запятыми список элементов, подлежащих сохранению, без какого-либо указания ключей. Результатом становится то, что элементы сохраняются в массиве в заданном порядке и им присваиваются целочисленные ключи, начинающиеся с нуля. Например, выполнение оператора:

// Создание числового массива с помощью конструкции array() $fruit = array('Апельсин', 'Яблоко', 'Банан', 'Груша');

приводит к тому, что имя переменной $fruit становится именем массива с четырьмя строковыми элементами (‘Апельсин’, ‘Яблоко’, ‘Банан’, ‘Груша’), имеющими соответственно индексы 0,1, 2 и 3. Кроме того массив запоминает порядок, в котором осуществлялась запись в него элементов. Таким образом, приведенная выше операция присваивания значения переменной $fruit влечет за собой получение точно такого же результата, как и следующие операции:

$fruit[0] = 'Апельсин'; $fruit[1] = 'Яблоко'; $fruit[2] = 'Банан'; $fruit[3] = 'Груша';

при условии, что во время первого присваивания переменная $fruit была несвязанной. Аналогичного эффекта можно также достичь, исключая индексы в операции присваивания, как в следующем примере:

$fruit[] = 'Апельсин'; $fruit[] = 'Яблоко'; $fruit[] = 'Банан'; $fruit[] = 'Груша';

В данном случае интерпретатор PHP действует на основании предположения, что добавляются последовательные элементы, которые должны иметь целочисленные индексы, отсчитываемые от нуля в сторону увеличения.

Следует еще раз подчеркнуть, что по умолчанию нумерация индексов массива начинается с нуля, а не с единицы. Такое соглашение о нумерации индексов массивов принято в большинстве языков программирования.

В простом примере конструкции array(), приведенном в предыдущем примере, присваивание индексов элементам осуществлялось автоматически, но такие индексы являются исключительно целочисленными и отсчитываются в сторону увеличения от нуля, поэтому указанный подход не предоставляет широкого выбора. Но, как оказалось, конструкция array() обеспечивает возможность использовать специальную синтаксическую структуру для создания ассоциативных массивов. Вместо перечисления значений элементов, разделенных запятыми, в этой конструкции можно задать разделенные запятыми пары «ключ-значение», в которых ключ и значение разделены с помощью специального символа =>. Рассмотрим следующий оператор:

$fruit = array(0 => 'Апельсин', 1 => 'Яблоко', 2 => 'Банан', 3 => 'Груша');

Выполнение этого оператора приведет к получению такого же результата, как и выполнение приведенных выше вариантов операций присваивания — каждая строка будет сохранена в массиве последовательно и этим строковым значениям будут по порядку присвоены индексы 0, 1, 2, 3. Однако вместо этого можно использовать точно такую же синтаксическую структуру для сохранения тех же элементов, но со строковыми индексами:

$fruit = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша');

В результате этого в массив будут добавлены те же четыре элемента в том же порядке, но с выполнением индексации с помощью ключей, соответствующих названиям цветов, а не чисел. Например, чтобы извлечь из массива название фрукта желтого цвета, достаточно вычислить такое выражение:

// Этот элемент должен иметь значение 'Банан' $fruit['yellow'];

Функции, возвращающие массивы

Последний способ создания массива в сценарии состоит в вызове функции, которая возвращает массив. Это может быть функция, определяемая пользователем, или встроенная функция, создающая массив с помощью каких-то внутренних методов PHP.

Например, в виде динамически создаваемых массивов возвращают свои результаты многие функции, обеспечивающие взаимодействие с базой данных. Предусмотрены и другие функции, предназначенные исключительно для создания массивов, удобных для использования в качестве заготовок в применяемых впоследствии функциях манипулирования массивами. Одной из таких функций является range(), которая принимает два целых числа в качестве параметров и возвращает массив, заполненный всеми целыми числами (включительно), лежащими на числовой оси между этими параметрами. Иными словами, оператор $my_array = range(1,5); эквивалентен оператору $my_array = array(1, 2, 3, 4, 5);.

Выборка значений

Настоящий раздел позволяет найти ответ на вопрос о том, как осуществляется выборка значений из массива после их сохранения в этом массиве.

Выборка с помощью индекса или ключа

Самый непосредственный способ выборки значения элемента массива состоит в использовании индекса элемента. Например, если по индексу 5 в массив $my_array было записано некоторое значение, то вычисление выражения $my_array[5] должно привести к выборке хранимого значения.

Конструкция list()

Предусмотрено множество других способов выборки значений из массивов, в которых не используются ключи. Большинство из этих способов основано на том факте, что в массивах по умолчанию предусматривается регистрация элементов в том порядке, в каком происходила передача этих элементов на хранение. Конструкция list() применяется для присваивания нескольких значений подряд идущих элементов массива переменным. Допустим, что были выполнены два оператора:

$fruit = array('Апельсин', 'Яблоко', 'Банан', 'Груша'); list($fruit1, $fruit2) = $fruit;

В результате выполнения этих операторов происходит присваивание строки ‘Апельсин’ переменной $fruit1 и строки ‘Яблоко’ переменной $fruit2 (строка ‘Банан’ не присваивается какой-либо переменной, поскольку не было задано достаточное количество переменных). Переменным в конструкции list() значения элементов массива присваиваются в том порядке, в каком эти элементы были первоначально сохранены в массиве. Обратите внимание на то, насколько необычной является синтаксическая структура используемой операции присваивания — конструкция list() находится слева от знака операции присваивания (=), тогда как в этой позиции обычно можно встретить только имена переменных.

В определенном смысле конструкция list() является противоположной, или обратной, конструкции array(), поскольку array() упаковывает свои параметры в массив, а конструкция list() распаковывает массив, присваивая значения отдельным переменным.

Многомерные массивы

Во всех примерах, рассматриваемых до сих пор, массивы были одномерными, поскольку ключи, заданные в фигурных скобках, определяли только один уровень доступа к массиву. Но язык PHP позволяет легко обеспечить, поддержку многомерных массивов с произвольным количеством ключей. Многомерные массивы — это просто массивы, в которых хранятся другие массивы. Ниже показан пример создания числовых и ассоциативных многомерных массивов, а ниже блок-схема, поясняющая их использование:

// Два простых одномерных массива $counts = array(1, 2, 10, 14, -5); $fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); // Два двухмерных массива $counts2[0][0] = 1; $counts2[0][1] = 2; $counts2[0][2] = 3; $counts2[1][0] = 4; $counts2[1][1] = 5; $counts2[1][2] = 6; $counts2[2][0] = 7; $counts2[2][1] = 8; $counts2[2][2] = 9; $nature = array('fruit' => array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'), 'flower' => array('red' => 'Астра', 'white' => 'Роза', 'pink' => 'Пион', 'blue' => 'Колокольчик')); // Вывести на экран значение белого цветка echo $nature['flower']['white'];

Следует отметить, что попытка обратиться с помощью неправильного индекса к многомерному массиву для выборки какого-либо значения не влечет за собой сурового наказания; если соответствующий ключ не будет найден, то все выражение рассматривается как несвязанная переменная.

Получение сведений о массивах

Выше было описано, как создавать массивы, сохранять значения в массивах, а затем снова извлекать значения, когда они потребуются. В таблице ниже приведены краткие сведения о функциях некоторых других типов, которые могут использоваться для получения информации о массивах.

Простые PHP-функции для получения сведений о массивах

Функция	Описание
is_array()	Принимает единственный параметр любого типа и возвращает истинное значение, если этот параметр является массивом; в противном случае возвращает ложное значение
count()	Принимает в качестве фактического параметра массив и возвращает количество непустых элементов в массиве
sizeof()	Идентична count()
in_array()	Принимает два фактических параметра: элемент (который может быть записан в массив в качестве значения) и массив (который может содержать элемент). Возвращает истинное значение, если элемент содержится в массиве в качестве значения; в противном случае возвращает ложное значение. (Обратите внимание на то, что эта функция не выполняет проверку на наличие в массиве определенных ключей.)
isSet($array[$key])	Принимает форму array[key] и возвращает истинное значение, если часть, обозначенная ключом key, представляет собой допустимый ключ для массива array. (Это — специализированный способ использования более общей функции isSet(), который проверяет, является ли переменная связанной.)

Следует отметить, что все эти функции действуют только на глубину одного уровня заданного массива, поэтому для получения данных о значениях, хранящихся в многомерном массиве на более глубоких уровнях, необходимо указать, на каком уровне должна быть получена информация. Ниже показан пример в случае приведенного выше двухмерного массива $nature:

echo count($nature); // 2 echo count($nature['flower']); // 4

Удаление элементов из массивов

Операция удаления элемента из массива является простой и полностью аналогичной операции удаления значения, присвоенного переменной. Достаточно просто вызвать функцию unset(), как показано ниже:

$my_array[0] = 'значение'; $my_array[1] = 'это значение нужно удалить'; $my_array[2] = 'еще одно значение'; unset($my_array[1]);

После завершения выполнения кода эта переменная $my_array будет содержать два значения (‘значение’, ‘еще одно значение’), ассоциированные с двумя индексами (соответственно 0 и 2).

Следует отметить, что операция удаления элемента не аналогична операции присваивания элементу пустого значения. Например, если вместо вызова функции unset() был применен следующий оператор:

$my_array[1] = '';

то в конечном итоге массив содержал бы три хранимых значения (‘значение’, », ‘еще одно значение’), ассоциированных с тремя индексами (соответственно 0, 1 и 2).

Итерация массивов

Массивы PHP не только сохраняют значения, ассоциированные с соответствующими ключами, но и по умолчанию образуют упорядоченный список пар «ключ-значение», хранящийся в том порядке, в котором происходила запись этих пар в массив. Такая структура массива была принята исходя из тех соображений, чтобы массив можно было использовать для обеспечения итерации по всему содержимому массива. (Следует отметить, что эту задачу трудно выполнить, просто сформировав цикл, который наращивает значение индекса, поскольку индексы массивов PHP не обязательно должны быть числовыми.)

В действительности в структуру массивов встроена своего рода скрытая система указателей. Каждая хранимая пара «ключ-значение» указывает на следующую, и одним из побочных эффектов этого становится то, что текущий указатель указывает на самый первый элемент и остается направленным именно на этот элемент, если не будет сдвинут в результате выполнения одной из итеративных функций.

В каждом массиве некоторая определенная хранимая пара «ключ-значение» запоминается как текущая, и определенная часть действий итеративных функций массива основана на принципе передвижения этого маркера текущей пары по внутреннему списку ключей и значений. Мы будем называть этот маркер , но следует учитывать, что язык PHP не поддерживает полноценные указатели в том смысле, в каком это понятие трактуют программисты, работающие на языках C/C++/C#. К тому же термин текущий указатель, применяемый в указанном смысле, будет появляться только в контексте описания средств итерации по элементам массива.

Рассматриваемая система указателей на основе связного списка представляет собой альтернативный способ получения информации о массивах и манипулирования ими. Система указателей существует наряду с системой, обеспечивающей запись в массив и выборку из массива на основе ключей.

Цикл foreach

Для организации циклической обработки массива можно использовать цикл foreach. Безусловно, создается впечатление, что эта конструкция унаследована от конструкции foreach языка Perl, но имеет немного странную синтаксическую структуру (которая, тем не менее, не совпадает со странной синтаксической структурой аналогичной конструкции из языка Perl). Синтаксическая структура конструкции foreach в языке PHP имеет две разновидности, и решение о том, какая из них должна использоваться в программе, зависит от того, требуется ли выборка и ключей, и значений массива или только значений:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); // Использование цикла foreach для извлечения только значений foreach ($fruits as $value) < echo $value.'
'; > echo '
'; // Использование цикла foreach для извлечения значений и ключей foreach ($fruits as $key => $f) < echo ''.$key.' => '.$f.'
'; >

Итеративные функции

Мне нравится конструкция foreach, но в действительности она применима лишь в таких ситуациях, когда требуется просто обработать в цикле значения, хранящиеся в массиве. Для получения дополнительного контроля над кодом обработки необходимо использовать итеративные функции, которые описаны в таблице ниже:

Значение из пары «ключ-значение», на которую в настоящее время указывает внутренний «текущий» указатель (или ложное значение, если таковое значение отсутствует)

Продвигает указатель на один элемент. Если указатель уже направлен на последний элемент, эта функция продвигает указатель «за пределы массива», поэтому последующий вызов функции current() возвратит ложное значение

Значение, на которое направлен указатель после его продвижения (или ложное значение, если текущее значение отсутствует, т.е. указатель вышел за пределы массива)

Продвигает указатель в обратном направлении на один элемент. Если указатель уже направлен на первый элемент, продвигает указатель за пределы массива, устанавливая его «перед началом массива»

Значение, на которое направлен указатель после его продвижения в обратном направлении (или ложное значение, если текущее значение отсутствует, т.е. указатель вышел за пределы массива)

Продвигает указатель в обратном направлении так, чтобы он указывал на первую пару «ключ-значение» (или занял позицию «перед началом массива», если массив пуст)

Первое значение, хранящееся в массиве, или ложное значение, в случае пустого массива

Перемещает указатель в прямом направлении и устанавливает его на последнюю пару «ключ-значение»

Последнее значение, которое находится в настоящее время в списке пар «ключ-значение»

Отсутствует (Эта функция является псевдонимом функции current().)

Значение пары «ключ-значение», на которую в настоящее время направлен указатель

Перемещает указатель вперед, на следующую пару «ключ-значение»

Массив, который содержит данные о ключе и значении из пары «ключ-значение», которая была текущей до перемещения указателя (или ложное значение, если текущая пара отсутствует, т.е. указатель находится за пределами массива). В возвращенном массиве ключ и значение хранятся под собственными ключами массива, соответственно 0 и 1, а также под собственными ключами массива, соответственно ‘key’ и ‘value’

Функция array_walk() вызывает функцию, указанную в качестве второго фактического параметра, применительно к каждой паре «ключ-значение». Побочные эффекты зависят от побочных эффектов переданной функции

Возвращает значение 1

Функция current() возвращает сохраненное значение, на которое в настоящее время направлен указатель. Во вновь созданном массиве с элементами текущий указатель всегда направлен на первый элемент. Функция next() вначале продвигает указатель, а затем возвращает текущее значение, на которое направлен указатель. Если функция next() вызывается в тех условиях, когда текущий указатель уже направлен на последнее хранимое значение и поэтому должен выйти за конец массива, функция возвращает ложное значение.

В качестве примера рассмотрим вывод содержимого массива с помощью итеративных функций current() и next(), как показано ниже:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); function print_all_next($array) < $current = current($array); if ($current) echo $current.'
'; else echo 'Указатель не найден'; while ($current = next($array)) echo $current.'
'; echo '
'; > print_all_next($fruits); print_all_next($fruits); // Инициируем повторный вызов, // чтобы посмотреть что произойдет

После выполнения данного кода вывода массива снова будут получены такие данные:

В связи с получением приведенных здесь результатов возникает вопрос: как получилось, что второй вызов функции print_all_next() привел к получению прежних результатов? Как удалось вернуть текущий указатель в начало, чтобы снова повторить все операции во второй раз? Ответ обусловлен тем фактом, что вызовы функций PHP представляют собой вызовы по значению. Таким образом, в функцию передаются копии параметров и функция оперирует этими копиями, а не самими параметрами. Поэтому в обоих этих вызовах функции передается немодифицированная копия массива, используемого в качестве параметра, а сам массив не затрагивается в результате вызова функции next().

Предыдущий пример показывает, как можно написать собственную функцию, являющуюся частичным аналогом цикла foreach. Но цикл foreach позволяет отображать также ключи. Давайте модифицируем наш пример, добавив к выводу на экран ключи с помощью функции key():

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); function print_all_next($array) < $current = current($array); $current_key = key($array); if ($current) echo "$current_key => ".$current.'
'; else echo 'Указатель не найден'; while ($current = next($array)) < $current_key = key($array); echo "$current_key => ".$current.'
'; > echo '
'; > print_all_next($fruits);

Средства преобразования массивов

В языке PHP предусмотрен целый ряд функций, позволяющих манипулировать данными после того, как эти данные для обеспечения удобства в работе будут сохранены в виде массивов. Общей отличительной особенностью функций, рассматриваемых в этом разделе, является то, что все они принимают в качестве параметра массив, выполняют с ним определенные действия и возвращают результаты в виде другого массива (описание функций сортировки массивов будет приведено в одном из следующих разделов).

Функции манипулирования массивами приведены в таблице ниже:

Функции преобразования массивов

Описание	Функция
array_keys()	Принимает единственный параметр в виде массива и возвращает новый массив, значениями которого являются ключи входного массива, а ключами — последовательно возрастающие целые числа, начиная с нуля
array_values()	Принимает единственный параметр в виде массива и возвращает новый массив, значениями которого являются значения входного массива, а ключами — последовательно возрастающие целые числа, начиная с нуля
array_count_values()	Принимает единственный параметр в виде массива и возвращает новый массив, ключами которого являются значения входного массива, а значениями — данные о том, сколько раз первоначальное значение встретилось во входном массиве
array_flip()	Принимает единственный параметр в виде массива и изменяет его так, что ключами становятся значения, и наоборот
array_reverse()	Принимает единственный параметр в виде массива и изменяет внутреннее упорядочение пар «ключ-значение» на противоположное. При наличии в массиве числовых целочисленных ключей происходит также их перенумерация
shuffle()	Принимает единственный параметр в виде массива и изменяет случайным образом внутреннее упорядочение пар «ключ-значение». Происходит также перенумерация целочисленных ключей в соответствии с новым упорядочением. В процессе выполнения функции shuffle() используется генератор случайных чисел rand(), поэтому перед вызовом этой функции необходимо предварительно вызывать функцию srand() для инициализации начального значения генератора (об этом говорится в следующей статье)
array_merge()	Принимает два параметра в виде двух массивов, выполняет их слияние и возвращает новый массив, состоящий из элементов первого массива (в исходном порядке), за которыми следуют элементы второго массива.

Давайте на примерах рассмотрим эти функции более подробно.

Выборка ключей и значений

Функция array_keys() возвращает ключи массива, заданного в качестве входного параметра, в форме нового массива, ключами которого являются хранимые значения. Ключами нового массива становятся обычные индексы в виде автоматически наращиваемых целых чисел, которые начинаются с нуля. Функция array_values() выполняет точно такое же действие, если не считать того, что хранимыми значениями становятся значения из первоначального массива:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); echo 'Массив ключей: 
'; foreach (array_keys($fruits) as $key => $value) < echo ''.$key.' => '.$value.'
'; > echo '
Массив значений: 
'; foreach (array_values($fruits) as $key => $value) < echo ''.$key.' => '.$value.'
'; >

По-видимому, результаты применения второй из рассматриваемых функций (array_values()) представляют меньший интерес, поскольку эта функция фактически принимает исходный массив и формирует новый массив, ключи которого заменены последовательно возрастающими числами.

Немного более полезную операцию (способную оказать большую помощь при решении задачи упорядочения) можно выполнить с помощью функции array_count_values(). Эта функция принимает в качестве параметра массив и возвращает новый массив, в котором старые значения преобразованы в новые ключи, а новые значения показывают, сколько раз каждое старое значение встречается в первоначальном массиве.

Зеркальное отображение, обращение и случайное перемешивание

Более редко применяемой функцией по сравнению с описанными выше является функция array_flip(), которая преобразует ключи массива в значения, и наоборот. Следует отметить, что гарантируется уникальность ключей массива, а на значения массива такая гарантия не распространяется. В связи с этим любые дублирующиеся значения в первоначальном массиве преобразуются в один и тот же ключ в новом массиве. Поэтому сохраняется только один из первоначальных ключей, который становится соответствующим новым значением.

Операция обращения массива является менее сложной: функция array_reverse() возвращает новый массив, в котором пары «ключ-значение» находятся в обратном порядке.

Если в программу должны быть внесены некоторые дополнительные элементы случайности, то для этого можно воспользоваться функцией shuffle(). Функция shuffle() принимает в качестве параметра массив и изменяет случайным образом порядок элементов в массиве.

В следующем примере показано применение этих функций:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); // array_flip() echo 'Исходный массив: 
'; foreach ($fruits as $key => $value) < echo ''.$key.' => '.$value.'
'; > echo '
Массив после использования функции array_flip(): 
'; $fruits = array_flip($fruits); foreach ($fruits as $key => $value) < echo ''.$key.' => '.$value.'
'; > // array_reverse() echo '
Исходный массив: 
'; $array = range(1,5); foreach ($array as $value) < echo $value.' '; >echo '
Массив после использования функции array_reverse(): 
'; $array = array_reverse($array); foreach ($array as $value) < echo $value.' '; >// shuffle() echo '

Исходный массив: 
'; $array = range(1,10); foreach ($array as $value) < echo $value.' '; >echo '
Массив после использования функции shuffle(): 
'; srand((double)microtime()*1000000); // Применяется для выработки случайных чисел shuffle($array); foreach ($array as $value)

В отличие от многих других функций работы с массивами, приведенных в данной статье, функция shuffle() является деструктивной. Это означает, что она применяется непосредственно к массиву, заданному в качестве параметра, и изменяет его, а не возвращает вновь созданный массив. (Функции, возвращающие новый объект и не изменяющие свои параметры, принято называть конструктивными, или недеструктивными.) Кроме всего прочего, это означает, что правильный способ вызова рассматриваемой функции случайного перемешивания элементов не является таковым:

$array = shuffle($array); // Неправильная конструкция!

Слияние, дополнение, вырезка и вставка элементов массивов

Если требуется объединить два массива, например для получения более полного списка, то можно воспользоваться функцией array_merge(). Эта функция принимает в качестве параметров два или несколько массивов и возвращает новый массив с перенумерованными ключами, в котором второй массив присоединен к концу первого. Например:

$new_array = array_merge(range(0,2), array(5,6,7), array(10,11)); // [0,1,2,5,6,7,10,11]

Функция array_pad() используется для создания определенного количества ведущих или заключительных пар «ключ-значение» в целях увеличения размера массива. Эта функция принимает в качестве первого параметра входной массив. Вслед за этим параметром должно быть указано количество элементов, на которое увеличивается массив, а затем — значение, присваиваемое дополнительным элементам. Если в качестве второго параметра задано положительное целое число, то массив дополняется в конце, а в случае указания отрицательного целого числа массив дополняется в начале. Если второй параметр меньше размера массива, дополнение не выполняется:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); foreach (array_pad($fruits, 10, 'empty') as $key => $value) < echo ''.$key.' => '.$value.'
'; >

Обратите внимание на то, что автоматически присваиваемые ключи начинаются с нуля, даже несмотря на то, что они отсчитываются от пятой позиции.

Немного более сложными являются функции array_slice() и array_splice(). Первая из них возвращает подмножество элементов входного массива, принимая в качестве второго и третьего параметров смещение и длину соответственно. Функция array_splice() аналогична функции array_slice(), но принимает четвертый параметр, который может представлять собой массив любой длины, предназначенный для вставки во входной массив.

Стеки и очереди

Стеки и очереди представляют собой абстрактные структуры данных, часто используемые в программировании, которые налагают требования по использованию определенных правил доступа к содержащимся в них объектам, причем эти правила практически не зависят от типа самих объектов. Массивы языка PHP хорошо подходят для решения задач эмуляции структур данных других типов, к тому же благодаря отсутствию строгой типизации элементов массива PHP появляется возможность легко эмулировать с помощью массивов такие структуры данных, как стеки и очереди. В языке PHP предусмотрены некоторые функции работы с массивами, специально предназначенные для этой цели. Если в программе используются исключительно такие функции, то программист может даже не учитывать, что в основе рассматриваемых структур данных лежат массивы.

представляет собой контейнер, который сохраняет значения и поддерживает операции доступа к этим значениям по принципу обратной очереди (last-in-first-out — LIFO). Это означает, что стек поддерживает порядок сохраняемых в нем значений и предоставляет единственный способ выборки сохраненного в нем значения — извлечение (и удаление) последнего по времени сохраненного значения:

Обычно для описания стека применяется такая аналогия — стопка подносов в кафетерии перед одной из линий раздачи, из которой посетители берут подносы, снимая их сверху, а служащие постоянно пополняют запас подносов, также накладывая их сверху. Новые подносы можно помещать поверх уже имеющихся и брать имеющиеся сверху, но до помещенного ранее подноса невозможно добраться, не сняв перед этим помещенные позже подносы.

Очередь аналогична стеку, но действует по принципу последовательной очереди (first-in-first-out — FIFO). Обычно для описания такой очереди применяется аналогия с цепочкой людей, ожидающих обслуживания, которую в Англии обозначают queue, а в США — line. Общее правило обслуживания людей, стоящих в очереди, состоит в том, что следующим должен обслуживаться тот, кто простоял в очереди дольше всех:

Для работы со стеками применяются функции array_push() и array_pop(). Функция array_push() принимает в качестве параметра исходный массив, за которым может быть указано любое количество элементов, заталкиваемых в стек. Элементы вставляются в конце массива, в последовательности слева направо. Функция array_pop() принимает в качестве параметра такой массив и удаляет элемент, находящийся в конце массива, возвращая этот элемент.

Сортировка массивов

Наконец, в языке PHP предусмотрено множество функций для сортировки массивов. Как было указано выше, иногда бывает сложно учесть различие между ситуацией, в которой применяются ассоциации «ключ-значение» в массиве, и ситуацией, в которой числовые ключи рассматриваются в качестве информации об упорядочении, подлежащей изменению после изменения порядка элементов. К счастью, в языке PHP предусмотрены варианты функций сортировки, в которых учитываются особенности ситуаций каждого из этих типов. Кроме того, язык PHP позволяет сортировать элементы по возрастанию или по убыванию, а также использовать функции упорядочения, предоставленные пользователем. Имена функций сортировки являются сокращенными, но содержат специальные буквенные обозначения (кроме части имени со словом sort), которые позволяют определить назначение функции. Ниже приведено краткое описание указанных буквенных обозначений:

Начальная буква «a» означает, что функция выполняет сортировку по значениям, но сохраняет ассоциации между парами «ключ-значение» в том виде, в котором они существуют.
Начальная буква «k» означает, что сортировка осуществляется по ключам, но ассоциации «ключ-значение» сохраняются.
Отсутствие начальной буквы «a» или «k» означает, что сортировка выполняется по значениям, но ассоциации «ключ-значение» не сохраняются. В частности, числовые ключи перенумеровываются, отражая новое упорядочение.
Буква «r» перед словом sort означает, что применяется обратный порядок сортировки.
Начальная буква «u» означает, что функция принимает второй параметр — имя определяемой пользователем функции, которая задает упорядочение любых двух элементов, подлежащих сортировке.

Эти простые правила помогут не запутаться в следующих функциях сортировки:

Функции сортировки массивов

Функция	Описание
asort()	Принимает единственный параметр в виде массива. Сортирует пары «ключ-значение» по значениям, но сохраняет отображение «ключ-значение» неизменным. Является очень удобной в работе с ассоциативными массивами
arsort()	То же, что и asort(), но сортирует в порядке по убыванию
ksort()	Принимает единственный параметр в виде массива. Сортирует пары «ключ-значение» по ключам, но поддерживает ассоциации «ключ-значение» неизменными
krsort()	То же, что и ksort(), но сортирует в порядке по убыванию
sort()	Принимает единственный параметр в виде массива. Сортирует пары «ключ-значение» массива по их значениям. Ключи могут быть перенумерованы в соответствии с новым упорядочением значений
rsort()	То же, что и sort(), но сортирует в порядке по убыванию
uasort()	Сортирует пары «ключ-значение» по значениям с использованием функции сравнения. Аналогична asort(), за исключением того, что фактическое упорядочение значений определяется вторым параметром, который представляет собой имя определяемой пользователем функции упорядочения. Эта функция должна возвращать отрицательное число, если ее первый параметр предшествует второму (согласно результатам применения функции сравнения), положительное число, если первый параметр следует за вторым, и нуль, если сравниваемые элементы являются одинаковыми
uksort()	Сортирует пары «ключ-значение» по ключам с использованием функции сравнения. Аналогична uasort(), за исключением того, что упорядочение осуществляется по ключам, а не по значениям
usort()	Сортирует массив по значениям с использованием предоставленной функции сравнения. Аналогична uasort(), за исключением того, что ассоциации «ключ-значение» не сохраняются (как и в функции sort())

Ниже показан простой пример сортировки в алфавитном порядке:

$fruits = array('orange' => 'Апельсин', 'red' => 'Яблоко', 'yellow' => 'Банан', 'green' => 'Груша'); sort($fruits); foreach ($fruits as $key => $value) < echo ''.$key.' => '.$value.'
'; >

Как видите функция sort() не только отсортировала значения, но и заменила текстовые ключи на числовые индексы. Если такое поведение нежелательно, то следует использовать функцию asort().

Переменные и массивы

Наподобие array(), функция list() не совсем функция, а языковая конструкция. Она используется для формирования списка переменных.

Замечание: list() работает только с цифровыми индексами массива и принимает ключи элементов начиная с 0.

Пример использования функции list():

$info = array(«coffee», «brown», «caffeine»);

// Выведем все переменные

list($drink, $color, $power) = $info;

echo «$drink is $color and $power makes it special.n»;

// Выведем первый и последний

list($drink, , $power) = $info;

echo «$drink has $power.n»;

// Выведем только третий

list( , , $power) = $info;

echo «I need $power!n»;

Пример использования функции list():

$result = mysql_query(«SELECT id, name, salary FROM employees», $conn);

while (list($id, $name, $salary) = mysql_fetch_row($result))

$salary

n» .

Пример использования функции list(): Индексы

$info = array(«coffee», «brown», «caffeine»);

array(3) < [2]=>string(8) «caffeine» [1]=> string(5) «brown» [0]=> string(6) «coffee»>

Функция поддерживается PHP 3, PHP 4, PHP 5

compact

Упаковывает в массив переменные из текущего контекста.

Синтаксис:

array compact(mixed varname1 [, mixed $varname2, . ])

Функция compact() упаковывает в массив переменные из текущего контекста (глобального или контекста функции), заданные своими именами в varname1, $varname2 и т.д. При этом в массиве образуются пары с ключами, равными содержимому varnameN, и значениями соответствующих переменных.

Число аргументов может быть неопределенное.

Если в аргументе указано имя несуществующей переменной, он пропускается. Действие этой функции противоположно функции extract().

Пример использования функции compact():

$city = «San Francisco»;

$location_vars = array(«city», «state»);

$result = compact(«event», «nothing_here», $location_vars);

В результате выполнения кода переменная $result имеет значение:

Array( [event] => SIGGRAPH [city] => San Francisco [state] => CA)

Почему же тогда параметры функции обозначены как mixed? Дело в том, что они могут быть не только строками, но и списками строк. В этом случае функция последнего перебирает все элементы этого списка, и упаковывает те переменные из текущего контекста, имена которых она встретила. Более того — эти списки могут, в свою очередь, также содержать списки строк, и т.д. Правда, последнее используется достаточно редко.

Пример использования функции compact():

Функция поддерживается PHP 4, PHP 5

extract

Импорт элементов массива в переменные.

Синтаксис:

int extract (array var_array [, int extract_type [, string prefix]])

Функция extract() используется для импортирования значений массива в строку. Эта функция берет ассоциативный массив var_array, использую ключ элемента как имя переменной, а значение элемента как значение полученной переменной. Для создания переменных из пары ключ = значение можно также использовать необязательные параметры extract_type и prefix.

Замечание: начиная с PHP версии 4.0.5 эта функция возвращала количество извлеченных переменных.

Функция extract() проверяет, действительно ли каждый ключ массива может быть названием переменной. Она также проверяет на наличие одинаковых названий получаемых переменных. В случае, если обнаруживаются недействительные или числовые ключи, поведение функции предопределяет параметр extract_type, который может принимать следующие значения:

Пример использования функции extract():

/* Предположим, что $var_array массив,

полученный при помощи функции wddx_deserialize */

$var_array = array(«color» => «blue»,

extract($var_array, EXTR_PREFIX_SAME, «wddx»);

echo «$color, $size, $shape, $wddx_sizen»;

blue, large, sphere, medium

Здесь переменная $size не была переписана, т.к. мы указали параметр EXTR_PREFIX_SAME. Если указать EXTR_SKIP, тогда переменная $wddx_size даже не была бы создана. Если указать EXTR_OVERWRITE, то переменная $size имела бы значение «medium». Если EXTR_PREFIX_ALL — то в результате были бы созданы переменные $wddx_color, $wddx_size, и $wddx_shape.

Лучше всего использовать ассоциативные массивы. Массивы с цифровыми ключами не могут быть использованы в этой функции, если установлены флаги EXTR_PREFIX_ALL или EXTR_PREFIX_INVALID.

Функция поддерживается PHP 3 = 3.0.7, PHP 4, PHP 5

Смотрите также

A simple trick that can help you to guess what diff/intersect or sort function does by name.

[suffix] assoc — additional index check. Compares both value and index.

Example: array_diff_assoc, array_intersect_assoc.

[suffix] key — index only check. Ignores value of array, compares only indexes.

Example: array_diff_key, array_intersect_key.

[suffix] **empty** — no «key» or «assoc» word in suffix. Compares values only. Ignores indexes of array.

Example: array_diff, array_intersect.

[prefix] u — will do comparison with user defined function. Letter u can be used twice in some functions (like array_udiff_uassoc), this means that you have to use 2 functions (one for value, one for index).

Example: array_udiff_uassoc, array_uintersect_assoc.

This also works with array sort functions:

[prefix] a — associative. Will preserve keys.

Example: arsort, asort.

[prefix] k — key sort. Will sort array by keys.

Example: uksort, ksort.

[prefix] r — reverse. Will sort array in reverse order.

Example: rsort, krsort.

[prefix] u — sort by user defined function (same as for diff/intersect).

Example: usort, uasort.

15 years ago

Big arrays use a lot of memory possibly resulting in memory limit errors. You can reduce memory usage on your script by destroying them as soon as you´re done with them. I was able to get over a few megabytes of memory by simply destroying some variables I didn´t use anymore.
You can view the memory usage/gain by using the funcion memory_get_usage(). Hope this helps!

4 years ago

I need to take an element from the Array and change its position within the Array by moving the rest of the elements as required.
This is the function that does it. The first parameter is the working Array. The second is the position of the element to move and the third is the position where to move the element.
The function returns the modified Array.
function array_move_elem ( $array , $from , $to ) if ( $from == $to ) < return $array ; >
$c = count ( $array );
if (( $c > $from ) and ( $c > $to )) if ( $from < $to ) $f = $array [ $from ];
for ( $i = $from ; $i < $to ; $i ++) $array [ $i ] = $array [ $i + 1 ];
>
$array [ $to ] = $f ;
> else $f = $array [ $from ];
for ( $i = $from ; $i > $to ; $i —) $array [ $i ] = $array [ $i — 1 ];
>
$array [ $to ] = $f ;
>

?>
Examples:
$array = array( ‘Cero’ , ‘Uno’ , ‘Dos’ , ‘Tres’ , ‘Cuatro’ , ‘Cinco’ , ‘Seis’ , ‘Siete’ , ‘Ocho’ , ‘Nueve’ , ‘Diez’ );
$array = array_move_elem ( $array , 3 , 5 ); // Move element in position 3 to position 5.
print_r ( $array );

$array = array_move_elem ( $array , 5 , 3 ); // Move element in position 5 to position 3, leaving array as it was. 😉
print_r ( $array );

?>
Return:
Array ( [ 0 ] => Cero [ 1 ] => Uno [ 2 ] => Dos [ 3 ] => Cuatro [ 4 ] => Cinco [ 5 ] => Tres [ 6 ] => Seis [ 7 ] => Siete [ 8 ] => Ocho [ 9 ] => Nueve [ 10 ] => Diez )
Array ( [ 0 ] => Cero [ 1 ] => Uno [ 2 ] => Dos [ 3 ] => Tres [ 4 ] => Cuatro [ 5 ] => Cinco [ 6 ] => Seis [ 7 ] => Siete [ 8 ] => Ocho [ 9 ] => Nueve [ 10 ] => Diez )
?>

17 years ago

Here is a function to find out the maximum depth of a multidimensional array.

// return depth of given array
// if Array is a string ArrayDepth() will return 0
// usage: int ArrayDepth(array Array)

function ArrayDepth ( $Array , $DepthCount =- 1 , $DepthArray =array()) $DepthCount ++;
if ( is_array ( $Array ))
foreach ( $Array as $Key => $Value )
$DepthArray []= ArrayDepth ( $Value , $DepthCount );
else
return $DepthCount ;
foreach( $DepthArray as $Value )
$Depth = $Value > $Depth ? $Value : $Depth ;
return $Depth ;
>
?>

3 years ago

Updated code of ‘indioeuropeo’ with option to input string-based keys.

FUNCTION:
function array_move_elem ( $array , $from , $to ) // return if non-numeric couldn’t be found or from=to
if(! is_numeric ( $from )) if( array_search ( $from , array_keys ( $array ))!== FALSE ) $from = array_search ( $from , array_keys ( $array ));
>else return $array ;
>
>
$array_numeric_keys = array();
foreach( $array as $k => $v ) $array_numeric_keys [] = $k ;
>
if ( $from == $to ) < return $array ; >
$c = count ( $array_numeric_keys );
if (( $c > $from ) and ( $c > $to )) if ( $from < $to ) $f = $array_numeric_keys [ $from ];
for ( $i = $from ; $i < $to ; $i ++) $array_numeric_keys [ $i ] = $array_numeric_keys [ $i + 1 ];
>
$array_numeric_keys [ $to ] = $f ;
> else $f = $array_numeric_keys [ $from ];
for ( $i = $from ; $i > $to ; $i —) $array_numeric_keys [ $i ] = $array_numeric_keys [ $i — 1 ];
>
$array_numeric_keys [ $to ] = $f ;
>

>
$array_new = array();
foreach( $array_numeric_keys as $v ) $array_new [ $v ] = $array [ $v ];
>
return $array_new ;
>
?>

11 years ago

Short function for making a recursive array copy while cloning objects on the way.

function arrayCopy ( array $array ) $result = array();
foreach( $array as $key => $val ) if( is_array ( $val ) ) $result [ $key ] = arrayCopy ( $val );
> elseif ( is_object ( $val ) ) $result [ $key ] = clone $val ;
> else $result [ $key ] = $val ;
>
>
return $result ;
>
?>

12 years ago

While PHP has well over three-score array functions, array_rotate is strangely missing as of PHP 5.3. Searching online offered several solutions, but the ones I found have defects such as inefficiently looping through the array or ignoring keys.

The following array_rotate() function uses array_merge and array_shift to reliably rotate an array forwards or backwards, preserving keys. If you know you can trust your $array to be an array and $shift to be between 0 and the length of your array, you can skip the function definition and use just the return expression in your code.

function array_rotate ( $array , $shift ) if(! is_array ( $array ) || ! is_numeric ( $shift )) if(! is_array ( $array )) error_log ( __FUNCTION__ . ‘ expects first argument to be array; ‘ . gettype ( $array ). ‘ received.’ );
if(! is_numeric ( $shift )) error_log ( __FUNCTION__ . ‘ expects second argument to be numeric; ‘ . gettype ( $shift ). » ` $shift ` received.» );
return $array ;
>
$shift %= count ( $array ); //we won’t try to shift more than one array length
if( $shift < 0 ) $shift += count ( $array ); //handle negative shifts as positive
return array_merge ( array_slice ( $array , $shift , NULL , true ), array_slice ( $array , 0 , $shift , true ));
>
?>
A few simple tests:
$array =array( «foo» => 1 , «bar» => 2 , «baz» => 3 , 4 , 5 );

print_r ( array_rotate ( $array , 2 ));
print_r ( array_rotate ( $array , — 2 ));
print_r ( array_rotate ( $array , count ( $array )));
print_r ( array_rotate ( $array , «4» ));
print_r ( array_rotate ( $array , — 9 ));
?>

8 years ago

/*to change an index without rewriting the whole table and leave at the same place.
*/
function change_index (& $tableau , $old_key , $new_key ) $changed = FALSE ;
$temp = 0 ;
foreach ( $tableau as $key => $value ) switch ( $changed ) case FALSE :
//creates the new key and deletes the old
if ( $key == $old_key ) $tableau [ $new_key ] = $tableau [ $old_key ];
unset( $tableau [ $old_key ]);
$changed = TRUE ;
>
break;

case TRUE :
//moves following keys
if ( $key != $new_key ) $temp = $tableau [ $key ];
unset( $tableau [ $key ]);
$tableau [ $key ] = $temp ;
break;
>
else < $changed = FALSE ;>//stop
>
>
array_values ( $tableau ); //free_memory
>

//Result :
$tableau = array( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 );
$res = print_r ( $tableau , TRUE );
$longueur = strlen ( $res ) — 1 ;
echo «Old array :\n» . substr ( $res , 8 , $longueur ) . «\n» ;

change_index ( $tableau , 2 , ‘number 2’ );
$res = print_r ( $tableau , TRUE );
$longueur = strlen ( $res ) — 10 ;
echo «New array :\n» . substr ( $res , 8 , $longueur ) . «\n» ;

Что принимает массив в качестве параметров php