Меню

Вывести массив без индексов php

Массивы в PHP

Что такое массив

Массив — это переменная, которая может содержать в себе сразу несколько значений.

Например, так можно объявить массив с тремя значениями:

В коде выше мы создаём переменную $heroes и добавляем в неё 3 строки.

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

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

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

Результат в браузере:

PHP сообщает нам, что в переменной лежит массив (англ. array), в котором находится 0 значений.

Чтобы объявить массив с данными, просто перечислите значения в квадратных скобках:

Теперь в переменной $brands лежит массив, состоящий из трёх элементов.

Создание массивов с помощью квадратных скобок работает начиная с версии PHP 5.4. До этого использовался более громоздкий синтаксис:

Ключи и значения массива

Массив состоит из ключей (индексов) и соответствующих им значений. Это можно представить как таблицу:

Ключ Значение
Samsung
1 Apple
2 Nokia

У каждого значения есть свой ключ. В массиве не может быть несколько одинаковых ключей.

Вернёмся к предыдущему примеру и посмотрим, что лежит в массиве:

Результат в браузере:

Когда мы создаём массив без указания ключей, PHP генерирует их автоматически в виде чисел, начиная с 0.

Указание ключей происходит с помощью конструкции => :

Простые и ассоциативные массивы

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

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

Вывод массива

Вывод элементов массива выглядит следующим образом:

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

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

Результат в браузере:

Также вывести содержимое массива можно с помощью цикла foreach:

Подробней работу цикла foreach мы разберём в отдельном уроке.

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

Добавление новых элементов в массив выглядит следующим образом:

Но если название ключа не играет роли, его можно опустить:

Удалить элемент массива можно с помощью функции unset() :

Двумерные и многомерные массивы

В качестве значения массива мы можем передать ещё один массив:

В примере выше мы создали массив $human , а затем внутри него создали ещё один массив $human[‘hands’] . Результат в браузере:

Обратиться к элементу многомерного массива можно так:

Теперь мы можем хранить в одном массиве целую базу товаров:

Или альтернативный вариант:

Задача 1

1. Создайте массивы $user1 и $user2 , заполните ключи name и age в каждом массиве любыми значениями.
2. Увеличьте значение age у обоих массивов на 50%.
3. Выведите на экран значение ключа name обоих пользователей.

Задача 2

1. Создайте массив $city , добавьте в него ключ name с любым значением.

2. Создайте подмассив streets с любыми случайными улицами. Каждая улица должна иметь имя (name) и количество домов (buildings_count), а также подмассив из номеров домов (old_buildings), подлежащих сносу.

Источник

Вывести массив без индексов php

Массивы (arrays) — это упорядоченные наборы данных, представляющие собой список однотипных элементов.

Существует два типа массивов, различающиеся по способу идентификации элементов.

1. В массивах первого типа элемент определяется индексом в последовательности. Такие массивы называются простыми массивами.

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

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

Массивы могут быть как , так и .

Простые массивы и списки в PHP

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

Простые одномерные массивы

Обобщенный синтаксис элементов простого одномерного массива:

Массивы, индексами которых являются числа, начинающиеся с нуля — это списки:

php
// Простой способ инициализации массива
$ name s[ 0 ]= «Апельсин» ;
$ names [ 1 ]= «Банан» ;
$ names [ 2 ]= «Груша» ;
$ names [ 3 ]= «Помидор» ;
// Здесь: names — имя массива, а 0, 1, 2, 3 — индексы массива
?>

Доступ к элементам простых массивов (списков) осуществляется следующим образом:

php
// Простой способ инициализации массива
$ names [ 0 ]= «Апельсин» ;
$ names [ 1 ]= «Банан» ;
$ names [ 2 ]= «Груша» ;
$ names [ 3 ]= «Помидор» ;
// Здесь: names — имя массива, а 0, 1, 2, 3 — индексы массива

// Выводим элементы массивов в браузер:
echo $ names [ 0 ]; // Вывод элемента массива names с индексом 0
echo «
» ;
echo $ names [ 3 ]; // Вывод элемента массива names с индексом 3
// Выводит:
// Апельсин
// Помидор
?>

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

Простые массивы можно создавать, не указывая индекс нового элемента массива, это за вас сделает PHP. Вот пример:

php
// Простой способ инициализации массива, без указания индексов
$ names []= «Апельсин» ;
$ names []= «Банан» ;
$ names []= «Груша» ;
$ names []= «Помидор» ;
// PHP автоматически присвоит индексы элементам массива, начиная с 0

// Выводим элементы массивов в браузер:
echo $ names [ 0 ]; // Вывод элемента массива names с индексом 0
echo «
» ;
echo $ names [ 3 ]; // Вывод элемента массива names с индексом 3
// Выводит:
// Апельсин
// Помидор
?>

В рассмотренном примере вы можете добавлять элементы массива names простым способом, то есть не указывая индекс элемента массива:

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

Простые многомерные массивы

Обобщенный синтаксис элементов многомерного простого массива:

Пример простого многомерного массива:

php
// Многомерный простой массив:
$ arr [ 0 ][ 0 ]= «Овощи» ;
$ arr [ 0 ][ 1 ]= «Фрукты» ;
$ arr [ 1 ][ 0 ]= «Абрикос» ;
$ arr [ 1 ][ 1 ]= «Апельсин» ;
$ arr [ 1 ][ 2 ]= «Банан» ;
$ arr [ 2 ][ 0 ]= «Огурец» ;
$ arr [ 2 ][ 1 ]= «Помидор» ;
$ arr [ 2 ][ 2 ]= «Тыква» ;

// Выводим элементы массива:
echo «

» .$ arr [ 0 ][ 0 ]. «:

» .$ arr [ 0 ][ 1 ]. «:

Ассоциативные массивы в PHP

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

Ассоциативные массивы особенно удобны в ситуациях, когда элементы массива удобнее связывать со словами, а не с числами.

Итак, массивы, индексами которых являются строки, называются .

Одномерные ассоциативные массивы

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

php
// Ассоциативный массив
$ names [ «Иванов» ]= «Иван» ;
$ names [ «Сидоров» ]= «Николай» ;
$ names [ «Петров» ]= » р» ;
// В данном примере: фамилии — ключи ассоциативного массива
// , а имена — элементы массива names
?>

Доступ к элементам одномерных ассоциативных массивов осуществляется так же, как и к элементам обыкновенных массивов, и называется :

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

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

php
// Многомерный массив
$ A [ «Ivanov» ] = array ( «name» => «Иванов И.И.» , «age» => «25» , «email» => » ivanov@mail.ru » );
$ A [ «Petrov» ] = array ( «name» => «Петров П.П.» , «age» => «34» , «email» => » petrov@mail.ru » );
$ A [ «Sidorov» ] = array ( «name» => «Сидоров С.С.» , «age» => «47» , «email» => » sidorov@mail.ru » );
?>

Многомерные массивы похожи на записи в языке Pascal или структуры в языке C.

Доступ к элементам многомерного ассоциативного массива осуществляется следующим образом:

echo $A[«Ivanov»][«name»]; // Выводит Иванов И.И.
echo $A[«Petrov»][«email»]; // Выводит petrov@mail.ru

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

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

Источник

Работа с массивами PHP – создание, наполнение, удаление

Основные примеры работы с массивами PHP. Создание, наполнение, извлечение удаление значений.

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

Создать массив и заполнить его значениями

Можно применить функцию array_fill($start, $size, $value) , которая создаст массив с количеством $size элементов со значением $value , начиная с индекса $start .

Данный пример создает массив с тремя элементам «текст», ключи которых будут начинаться с нуля.

Результат:

Еще вариант – функция explode($delimiter, $string) , которая из строки $string создаст массив используя разделитель $delimiter , в данном примере запятая.

Результат:

Узнать количество элементов в массиве

Если массив ассоциативный (многомерный), то count() вернёт количество элементов только первого уровня. Чтобы получит количество всех элементов нужно использовать константу COUNT_RECURSIVE .

Добавление элементов в массив

Добавить значение в начало массива

array_unshift($array, $value) – добавляет одно или несколько элементов в начало массива.

Результат:

Добавить значение в конец массива

array_push($array, $value) – добавляет значение в конец массива.

Результат:

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

Получить первый элемент массива

Получить последний элемент массива

Получить часть (срез) массива

array_slice($array, $offset, $length) возвращает часть массива начиная с индекса $offset длиной $length .

  • Если $offset отрицательный, то отчет начинается с конца массива.
  • $length можно не указывать, тогда функция вернет все элементы до конца массива начиная с индекса $offset .

Результат:

Извлечь первый элемент массива

array_shift($array) – извлекает первый элемент из массива $array и возвращает его значение.

Результат:

Извлечь последний элемент массива

array_pop($array) – извлекает последний элемент из массива $array и возвращает его значение.

Результат:

Извлечь часть массива

Чтобы извлечь из массива часть можно применить функции array_slice() и array_diff() .

Результат:

Выбрать все значения из массива

array_values($array) – создает новый массив из исходного $array игнорируя его ключи.

Результат:

Выбрать все ключи массива

array_keys($array) – создает новый массив состоящий из ключей исходного массива.

Результат:

Выбирать случайные значения из массива

array_rand($array, $count) возвращает случайным образом один или несколько ключей из массива $array . Если $count больше единицы, то результат будет в виде массива.

Поиск и проверка элементов в массиве

Проверить, есть ли значение в массиве

Проверить, есть ли ключ в массиве

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

unset() – удаляет переменные и элементы массива по ключу.

В первом примере элемент удаляется по ключу, во втором по значению:

Результат:

Удаление пустых значений

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

Результат:

Если требуется удалить значения включая 0 , null , array() и т.д. можно применить следующее:

Источник

Массивы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Код PHP Структура одномерных и двухмерных массивов из примера

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Цикл foreach

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

Код PHP Использование цикла foreach

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Использование функций current() и next()

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

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

Код PHP Использование функции key() для получения ключей массива

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

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

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

Функция Параметры Побочный эффект Возвращаемое значение
current() Один фактический параметр с обозначением массива Отсутствует
next() Один фактический параметр с обозначением массива
prev() Один фактический параметр с обозначением массива
reset() Один фактический параметр с обозначением массива
end() Один фактический параметр с обозначением массива
pos() Один фактический параметр с обозначением массива
each() Один фактический параметр с обозначением массива
array_walk() Первый параметр — фактический параметр с обозначением массива, второй параметр — имя функции с двумя (или тремя) фактическими параметрами, которая вызывается применительно к каждой паре, состоящей из ключа и значения, а третий параметр — необязательный фактический параметр
Функции преобразования массивов

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

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

array_pad() Принимает три параметра: входной массив, количество элементов в дополненном массиве и значение, которое должно содержаться в дополнительных элементах. Возвращает новый массив, который дополнен элементами по следующим правилам. Если количество элементов в дополненном массиве превышает количество элементов во входном массиве, то массив дополняется справа до указанного количества элементов по такому принципу, как если бы были подряд выполнены такие операции присваивания: $my_array[] = $pad_value.

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

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

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

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

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

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

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

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

Код PHP Получение массива ключей и значений из исходного массива с помощью функций array_keys() и array_values()

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

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

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

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

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

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

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

Код PHP Использование функций array_flip(), array_reverse(), shuffle()

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

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

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

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

Код PHP Увеличение размера массива с помощью функции array_pad()

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

Немного более сложными являются функции 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())

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

Код PHP Использование функции sort()

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

Источник

Читайте также:  Чем чистят серебро до блеска