Hf jnf c vfccbdfvb

Учебник PHP

Практика

Важное

Регулярки

Работа с htaccess

Файлы, папки

Сессии и куки

Работа с БД

Практика по работе с БД в PHP

Перед чтением см. новые уроки раздела "Важное", которые появились выше.

Практика

Движок PHP

Продвинутые БД

Аутентификация

Практика

ООП и MVC

Абстрактные классы и интерфейсы

Трейты

ООП Магия

Практика

Практика: классы как набор методов

• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс ArrayConvertor
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс TagHelper
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс FormHelper
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс TableHelper
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс SessionShell
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс CookieShell
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс FileManipulator
• Урок №
  новая вкладка с new.code.mu
  . текст, код Практика: класс databaseShell TODO cart корзина flash шаблонизатор роутер контроллер кеш логи фалидатор

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

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

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

Массив создается с помощью функции []:

Пока созданный нами массив не содержит никаких данных. Заполним его названиями дней недели (для краткости пишу две буквы каждого дня):

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

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

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

Посмотреть содержимое массива с помощью echo мы, увы, не сможем. Попробуйте сделать так:

Вы увидите на экране слово Array вместо содержимого массива.

Для того, чтобы PHP вывел нам все элементы массива, нужно воспользоваться функцией var_dump:

Вот теперь мы действительно увидим все элементы нашего массива.

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

Как вывести отдельный элемент массива

Итак, массив месяцев мы составили и даже научились смотреть на него функцией var_dump. Однако, полезного пока мало, так как var_dump используется для отладки кода и выводит весь массив целиком.

Предположим, мы хотим вывести на экран среду.

Делается это так: нужно после переменной массива (в нашем случае $a) написать квадратные скобки [ ], а в них указать порядковый номер элемента, который мы хотим вывести: $a[3]. Казалось бы, что порядковый номер среды — это 3, но это не так. Потому что в программировании нумерация начинается с нуля . Поэтому 0 — это понедельник, 1 — это вторник, а 2 — это среда.

Посмотрите и повторите пример:

Ассоциативный массив

Чтобы обратиться к нужному элементу массива, мы писали в квадратных скобках его порядковый номер (нумерация начинается с нуля, если вы уже забыли). Эти порядковые номера называются ключами массива. То есть мы получали значение элемента массива по его ключу.

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

Поэтому в PHP можно указать ключи в явном виде – так, как нам нужно. Сделаем так, чтобы понедельник имел ключ 1, а не ноль, как было раньше (и всем остальным дням прибавим единицу):

Синтаксис здесь такой: ключ, затем идет стрелка =>, а потом значение.

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

Узнаем зарплату Васи:

Массивы, у которых явно указаны ключи, называются ассоциативными.

Хитрость с ключами

Когда мы делали ассоциативный массив дней недели, нам приходилось расставлять все ключи вручную. И все для того, чтобы нумерация началась не с нуля, а с единицы. Это было немного неудобно.

Напомню вам этот массив:

На самом деле нет необходимости расставлять ключи всем элементам — достаточно только первому элементу поставить ключ 1.

Если у второго элемента не будет ключа, PHP поставит его автоматически, причем следующий по порядку.

А следующим номером будет как раз-таки число 2, так как предыдущий элемент имел ключ 1 (неважно, что мы сами его поставили, а не PHP автоматически).

Давайте поправим наш массив:

Итак, этот массив с одним нашим ключом фактически будет таким же, как и массив со всеми ключами, но сделать его проще — ключ ставится только первому элементу, а не всем.

Как еще можно создать массив

Объявление массива с помощью команды [] не является единственным способом его создания.

Можно просто присвоить значения элементам массива, не объявляя его через array (PHP нас поймет и сам создаст массив):

Естественно, ключи могут быть не только числовыми, но и текстовыми:

Кроме того, можно сделать так, что PHP сам добавит ключи (начиная с нуля и так далее). Для этого мы оставим квадратные скобки пустыми: $a[] = 1, а PHP сам добавит ключ. Пример:

Все способы создания массива

Итак, повторим все способы создания массива:

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

Элементы массива могут быть не только строками и числами, но и массивами. То есть у нас получится массив массивов или многомерный массив.

Давайте сделаем массив студентов $students, который будет содержать два подмассива: студенты мужского пола и женского:

Чтобы вывести какой-либо элемент из многомерного массива следует писать уже не одну пару [ ], а две: $a[‘boys’][0] – так мы выведем ‘Коля’.

Что вам делать дальше:

Приступайте к решению задач по следующей ссылке: задачи к уроку.

Когда все решите — переходите к изучению новой темы.

Массивы предоставляют множество методов. Чтобы было проще, в этой главе они разбиты на группы.

Добавление/удаление элементов

Мы уже знаем методы, которые добавляют и удаляют элементы из начала или конца:

• arr.push(. items) – добавляет элементы в конец,
• arr.pop() – извлекает элемент из конца,
• arr.shift() – извлекает элемент из начала,
• arr.unshift(. items) – добавляет элементы в начало.

splice

Как удалить элемент из массива?

Так как массивы – это объекты, то можно попробовать delete :

Вроде бы, элемент и был удалён, но при проверке оказывается, что массив всё ещё имеет 3 элемента arr.length == 3 .

Это нормально, потому что всё, что делает delete obj.key – это удаляет значение с данным ключом key . Это нормально для объектов, но для массивов мы обычно хотим, чтобы оставшиеся элементы сдвинулись и заняли освободившееся место. Мы ждём, что массив станет короче.

Поэтому для этого нужно использовать специальные методы.

Метод arr.splice(str) – это универсальный «швейцарский нож» для работы с массивами. Умеет всё: добавлять, удалять и заменять элементы.

Он начинает с позиции index , удаляет deleteCount элементов и вставляет elem1, . elemN на их место. Возвращает массив из удалённых элементов.

Этот метод проще всего понять, рассмотрев примеры.

Начнём с удаления:

Легко, правда? Начиная с позиции 1 , он убрал 1 элемент.

В следующем примере мы удалим 3 элемента и заменим их двумя другими.

Здесь видно, что splice возвращает массив из удалённых элементов:

Метод splice также может вставлять элементы без удаления, для этого достаточно установить deleteCount в 0 :

В этом и в других методах массива допускается использование отрицательного индекса. Он позволяет начать отсчёт элементов с конца, как тут:

slice

Метод arr.slice намного проще, чем похожий на него arr.splice .

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

Это похоже на строковый метод str.slice , но вместо подстрок возвращает подмассивы.

Можно вызвать slice и вообще без аргументов: arr.slice() создаёт копию массива arr . Это часто используют, чтобы создать копию массива для дальнейших преобразований, которые не должны менять исходный массив.

concat

Метод arr.concat создаёт новый массив, в который копирует данные из других массивов и дополнительные значения.

Он принимает любое количество аргументов, которые могут быть как массивами, так и простыми значениями.

В результате мы получаем новый массив, включающий в себя элементы из arr , а также arg1 , arg2 и так далее…

Если аргумент argN – массив, то все его элементы копируются. Иначе скопируется сам аргумент.

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

…Но если объект имеет специальное свойство Symbol.isConcatSpreadable , то он обрабатывается concat как массив: вместо него добавляются его числовые свойства.

Для корректной обработки в объекте должны быть числовые свойства и length :

Перебор: forEach

Метод arr.forEach позволяет запускать функцию для каждого элемента массива.

Например, этот код выведет на экран каждый элемент массива:

А этот вдобавок расскажет и о своей позиции в массиве:

Результат функции (если она вообще что-то возвращает) отбрасывается и игнорируется.

Поиск в массиве

Далее рассмотрим методы, которые помогут найти что-нибудь в массиве.

indexOf/lastIndexOf и includes

Методы arr.indexOf, arr.lastIndexOf и arr.includes имеют одинаковый синтаксис и делают по сути то же самое, что и их строковые аналоги, но работают с элементами вместо символов:

• arr.indexOf(item, from) ищет item , начиная с индекса from , и возвращает индекс, на котором был найден искомый элемент, в противном случае -1 .
• arr.lastIndexOf(item, from) – то же самое, но ищет справа налево.
• arr.includes(item, from) – ищет item , начиная с индекса from , и возвращает true , если поиск успешен.

Обратите внимание, что методы используют строгое сравнение === . Таким образом, если мы ищем false , он находит именно false , а не ноль.

Если мы хотим проверить наличие элемента, и нет необходимости знать его точный индекс, тогда предпочтительным является arr.includes .

Кроме того, очень незначительным отличием includes является то, что он правильно обрабатывает NaN в отличие от indexOf/lastIndexOf :

find и findIndex

Представьте, что у нас есть массив объектов. Как нам найти объект с определённым условием?

Здесь пригодится метод arr.find.

Его синтаксис таков:

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

• item – очередной элемент.
• index – его индекс.
• array – сам массив.

Если функция возвращает true , поиск прерывается и возвращается item . Если ничего не найдено, возвращается undefined .

Например, у нас есть массив пользователей, каждый из которых имеет поля id и name . Попробуем найти того, кто с >:

В реальной жизни массивы объектов – обычное дело, поэтому метод find крайне полезен.

Обратите внимание, что в данном примере мы передаём find функцию item => item. >, с одним аргументом. Это типично, дополнительные аргументы этой функции используются редко.

Метод arr.findIndex – по сути, то же самое, но возвращает индекс, на котором был найден элемент, а не сам элемент, и -1 , если ничего не найдено.

filter

Метод find ищет один (первый попавшийся) элемент, на котором функция-колбэк вернёт true .

На тот случай, если найденных элементов может быть много, предусмотрен метод arr.filter(fn).

Синтаксис этого метода схож с find , но filter возвращает массив из всех подходящих элементов:

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

Перейдём к методам преобразования и упорядочения массива.

Метод arr.map является одним из наиболее полезных и часто используемых.

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

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

sort(fn)

Вызов arr.sort() сортирует массив на месте, меняя в нём порядок элементов.

Он возвращает отсортированный массив, но обычно возвращаемое значение игнорируется, так как изменяется сам arr .

Не заметили ничего странного в этом примере?

Порядок стал 1, 15, 2 . Это неправильно! Но почему?

По умолчанию элементы сортируются как строки.

Буквально, элементы преобразуются в строки при сравнении. Для строк применяется лексикографический порядок, и действительно выходит, что "2" > "15" .

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

Функция должна для пары значений возвращать:

Например, для сортировки чисел:

Теперь всё работает как надо.

Давайте возьмём паузу и подумаем, что же происходит. Упомянутый ранее массив arr может быть массивом чего угодно, верно? Он может содержать числа, строки, объекты или что-то ещё. У нас есть набор каких-то элементов. Чтобы отсортировать его, нам нужна функция, определяющая порядок, которая знает, как сравнивать его элементы. По умолчанию элементы сортируются как строки.

Метод arr.sort(fn) реализует общий алгоритм сортировки. Нам не нужно заботиться о том, как он работает внутри (в большинстве случаев это оптимизированная быстрая сортировка). Она проходится по массиву, сравнивает его элементы с помощью предоставленной функции и переупорядочивает их. Всё, что остаётся нам, это предоставить fn , которая делает это сравнение.

Кстати, если мы когда-нибудь захотим узнать, какие элементы сравниваются – ничто не мешает нам вывести их на экран:

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

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

Это позволяет писать более короткие функции:

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

Будет работать точно так же, как и более длинная версия выше.

reverse

Метод arr.reverse меняет порядок элементов в arr на обратный.

Он также возвращает массив arr с изменённым порядком элементов.

split и join

Ситуация из реальной жизни. Мы пишем приложение для обмена сообщениями, и посетитель вводит имена тех, кому его отправить, через запятую: Вася, Петя, Маша . Но нам-то гораздо удобнее работать с массивом имён, чем с одной строкой. Как его получить?

Метод str.split(delim) именно это и делает. Он разбивает строку на массив по заданному разделителю delim .

В примере ниже таким разделителем является строка из запятой и пробела.

У метода split есть необязательный второй числовой аргумент – ограничение на количество элементов в массиве. Если их больше, чем указано, то остаток массива будет отброшен. На практике это редко используется:

Вызов split(s) с пустым аргументом s разбил бы строку на массив букв:

Вызов arr.join(glue) делает в точности противоположное split . Он создаёт строку из элементов arr , вставляя glue между ними.

reduce/reduceRight

Если нам нужно перебрать массив – мы можем использовать forEach , for или for..of .

Если нам нужно перебрать массив и вернуть данные для каждого элемента – мы используем map .

Методы arr.reduce и arr.reduceRight похожи на методы выше, но они немного сложнее. Они используются для вычисления какого-нибудь единого значения на основе всего массива.

Функция применяется по очереди ко всем элементам массива и «переносит» свой результат на следующий вызов.

• previousValue – результат предыдущего вызова этой функции, равен initial при первом вызове (если передан initial ),
• item – очередной элемент массива,
• index – его индекс,
• array – сам массив.

При вызове функции результат её вызова на предыдущем элементе массива передаётся как первый аргумент.

Звучит сложновато, но всё становится проще, если думать о первом аргументе как «аккумулирующем» результат предыдущих вызовов функции. По окончании он становится результатом reduce .

Этот метод проще всего понять на примере.

Тут мы получим сумму всех элементов массива всего одной строкой:

Здесь мы использовали наиболее распространённый вариант reduce , который использует только 2 аргумента.

Давайте детальнее разберём, как он работает.

1. При первом запуске sum равен initial (последний аргумент reduce ), то есть 0 , а current – первый элемент массива, равный 1 . Таким образом, результат функции равен 1 .
2. При втором запуске sum = 1 , и к нему мы добавляем второй элемент массива ( 2 ).
3. При третьем запуске sum = 3 , к которому мы добавляем следующий элемент, и так далее…

Поток вычислений получается такой:

В виде таблицы, где каждая строка –- вызов функции на очередном элементе массива:

sum	current	result
первый вызов	0	1	1
второй вызов	1	2	3
третий вызов	3	3	6
четвёртый вызов	6	4	10
пятый вызов	10	5	15

Здесь отчётливо видно, как результат предыдущего вызова передаётся в первый аргумент следующего.

Мы также можем опустить начальное значение:

Результат – точно такой же! Это потому, что при отсутствии initial в качестве первого значения берётся первый элемент массива, а перебор стартует со второго.

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

Но такое использование требует крайней осторожности. Если массив пуст, то вызов reduce без начального значения выдаст ошибку.

Поэтому рекомендуется всегда указывать начальное значение.

Метод arr.reduceRight работает аналогично, но проходит по массиву справа налево.

Array.isArray

Массивы не образуют отдельный тип языка. Они основаны на объектах.

Поэтому typeof не может отличить простой объект от массива:

…Но массивы используются настолько часто, что для этого придумали специальный метод: Array.isArray(value). Он возвращает true , если value массив, и false , если нет.

Большинство методов поддерживают «thisArg»

Почти все методы массива, которые вызывают функции – такие как find , filter , map , за исключением метода sort , принимают необязательный параметр thisArg .

Этот параметр не объяснялся выше, так как очень редко используется, но для наиболее полного понимания темы мы обязаны его рассмотреть.

Вот полный синтаксис этих методов:

Значение параметра thisArg становится this для func .

Например, вот тут мы используем метод объекта army как фильтр, и thisArg передаёт ему контекст:

Если бы мы в примере выше использовали просто users.filter(army.canJoin) , то вызов army.canJoin был бы в режиме отдельной функции, с this=undefined . Это тут же привело бы к ошибке.

Вызов users.filter(army.canJoin, army) можно заменить на users.filter(user => army.canJoin(user)) , который делает то же самое. Последняя запись используется даже чаще, так как функция-стрелка более наглядна.

Итого

Шпаргалка по методам массива:

Для добавления/удаления элементов:

• push (. items) – добавляет элементы в конец,
• pop() – извлекает элемент с конца,
• shift() – извлекает элемент с начала,
• unshift(. items) – добавляет элементы в начало.
• splice(pos, deleteCount, . items) – начиная с индекса pos , удаляет deleteCount элементов и вставляет items .
• slice(start, end) – создаёт новый массив, копируя в него элементы с позиции start до end (не включая end ).
• concat(. items) – возвращает новый массив: копирует все члены текущего массива и добавляет к нему items . Если какой-то из items является массивом, тогда берутся его элементы.

Для поиска среди элементов:

• indexOf/lastIndexOf(item, pos) – ищет item , начиная с позиции pos , и возвращает его индекс или -1 , если ничего не найдено.
• includes(value) – возвращает true , если в массиве имеется элемент value , в противном случае false .
• find/filter(func) – фильтрует элементы через функцию и отдаёт первое/все значения, при прохождении которых через функцию возвращается true .
• findIndex похож на find , но возвращает индекс вместо значения.

Для перебора элементов:

• forEach(func) – вызывает func для каждого элемента. Ничего не возвращает.

Для преобразования массива:

• map(func) – создаёт новый массив из результатов вызова func для каждого элемента.
• sort(func) – сортирует массив «на месте», а потом возвращает его.
• reverse() – «на месте» меняет порядок следования элементов на противоположный и возвращает изменённый массив.
• split/join – преобразует строку в массив и обратно.
• reduce(func, initial) – вычисляет одно значение на основе всего массива, вызывая func для каждого элемента и передавая промежуточный результат между вызовами.

• Array.isArray(arr) проверяет, является ли arr массивом.

Обратите внимание, что методы sort , reverse и splice изменяют исходный массив.

Изученных нами методов достаточно в 99% случаев, но существуют и другие.

Функция fn вызывается для каждого элемента массива аналогично map . Если какие-либо/все результаты вызовов являются true , то метод возвращает true , иначе false .

arr.fill(value, start, end) – заполняет массив повторяющимися value , начиная с индекса start до end .

arr.copyWithin(target, start, end) – копирует свои элементы, начиная со start и заканчивая end , в собственную позицию target (перезаписывает существующие).

Полный список есть в справочнике MDN.

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

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

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

Задачи

Переведите текст вида border-left-width в borderLeftWidth

Напишите функцию camelize(str) , которая преобразует строки вида «my-short-string» в «myShortString».

То есть дефисы удаляются, а все слова после них получают заглавную букву.

Содержание

User Contributed Notes 13 notes

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( ‘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 )
?>

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.

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 ;
>
?>

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( "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 ));
?>

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 ;
>
?>

I was looking for an array aggregation function here and ended up writing this one.

Note: This implementation assumes that none of the fields you’re aggregating on contain The ‘@’ symbol.

function array_group_by ( $flds , $arr ) <
$groups = array();
foreach ( $arr as $rec ) <
$keys = array_map (function( $f ) use( $rec ) < return $rec [ $f ]; >, $flds );
$k = implode ( ‘@’ , $keys );
if (isset( $groups [ $k ])) <
$groups [ $k ][] = $rec ;
> else <
$groups [ $k ] = array( $rec );
>
>
return $groups ;
>

If you need to flattern two-dismensional array with single values assoc subarrays, you could use this function:

function arrayFlatten ( $array ) <
$flattern = array();
foreach ( $array as $key => $value ) <
$new_key = array_keys ( $value );
$flattern [] = $value [ $new_key [ 0 ]];
>
return $flattern ;
>
?>

/*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 :
" . substr ( $res , 8 , $longueur ) . "
" ;

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