Как объявить массив в php
Перейти к содержимому

Как объявить массив в php

  • автор:

Массивы в PHP

Массивы — это один из наиболее популярных типов данных. На реальных проектах сайтов они являются лучшим помощником разработчика. Давайте создадим пустой массив. Это можно сделать несколькими способами:

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

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

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

 'Сыр', 6 => 'Мышь', 7 => 15, 8 => 'Кот', 9 => 18); echo $a[5]; // результат: 'Сыр' echo $a[6]; // результат: 'Мышь' echo $a[9]; // результат: '18' ?>

Рассмотрим способы добавления элемента в массив. Возьмём массив из последнего примера и добавим в него произвольные элементы несколькими разными способами:

 'Сыр', 6 => 'Мышь', 7 => 15, 8 => 'Кот', 9 => 18); $a[10] = 'Котята'; // добавит элемент в массив с ключом 10 и значением 'Котята' $a[] = 'молоко'; // добавит в конец массива элемент со значением 'молоко' array_push($a, 35); // добавит в конец массива элемент со значением 35 ?>

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

Массивы с числами в виде ключей сами по себе довольно бесполезны. Давайте же сделаем массив, который может встретиться в реальном проекте. К примеру, массив, который возникает в процессе авторизации пользователя на сайте. В этом массиве будут храниться логин, мэйл и пароль пользователя. Обычно такой массив делается во время приёма данных от пользователя, после ввода их в форму входа на сайт. И давайте сразу запишем массив в столбик для наглядности. С точки зрения PHP это не вызовет ошибки, но позволит нам лучше воспринимать информацию. В добавок вместо ключей-цифр поставим текст:

 'mouse', 'email' => 'mouse@mousedc.ru', 'password' => 'best_password' ); echo $a['login']; // результат: 'mouse' echo $a['email']; // результат: 'mouse@mousedc.ru' echo $a['password']; // результат: 'best_password' ?>

Такие массивы с текстовыми ключами называются ассоциативными. В программировании сайтов они встречаются намного чаще, чем массивы без ключей или с ключами-цифрами. Они сильно облегчают жизнь программистам.

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

Попробуем усложнить задачу — сделаем массив внутри массива. Это вполне законно с точки зрения PHP. Попробуем сделать вложенный массив в примере выше. Он будет находиться под ключом ‘info’. Запишем в него данные пользователя:

 'mouse', 'email' => 'mouse@mousedc.ru', 'password' => 'best_password', 'info' => array( 'name' => 'Mouse', 'color' => 'gray', ), ); echo $a['login']; // результат: 'mouse' echo $a['info']['name']; // результат: 'Mouse' ?>

Можно сделать массив с любым уровнем вложенности.

Строку в массив и обратно

Существуют функция explode, которая позволяет быстро создать массив из строки. Это довольно популярная функция, она часто используется в проектах. Приведём пример её использования:

'; print_r($b); echo '

'; ?>

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

Array ( [0] => Тише [1] => мыши [2] => кот на крыше )

Существует функция implode. По своей работе она противоположна explode и тоже часто используется в проектах. Эта функция объединяет элементы массива в строку. Первым параметром в этой функции ставится строка-соединитель, которая будет между элементами. Соединителем может быть любой символ, даже пробел и пустая строка (то есть без соединителя, все элементы будут слеплены):

Результат будет таким:

Тише, мыши, кот на крыше

PHP занятие 2. Массивы

Данный вариант инициализации массива сегодня практически не используется. Используется следующий вариант работы с массивами:

Данный вариант создания массива использует объект array :

1 2 3 4 5 6 7 8 9 10 11 12 13 14
$fruits = array( 1 => "яблоко", 2 => "груша", 3 => "апельсин", 4 => "абрикос" ); // Начиная с версии PHP 5.4 $fruits = array[ 1 => "яблоко", 2 => "груша", 3 => "апельсин", 4 => "абрикос" ];

$fruits = array( 1 => «яблоко», 2 => «груша», 3 => «апельсин», 4 => «абрикос» ); // Начиная с версии PHP 5.4 $fruits = array[ 1 => «яблоко», 2 => «груша», 3 => «апельсин», 4 => «абрикос» ];

Доступ к элементам массива

1 2 3 4 5 6 7 8
$fruits[0]="яблоко"; $fruits[1]="груша"; $fruits[2]="апельсин"; $fruits[3]="абрикос"; echo "Первый элемент массива - ". $fruits[0] ."
"
; echo "Второй элемент массива - ". $fruits[1] ."
"
; echo "Третий элемент массива - ". $fruits[2] ."
"
;

$fruits[0]=»яблоко»; $fruits[1]=»груша»; $fruits[2]=»апельсин»; $fruits[3]=»абрикос»; echo «Первый элемент массива — «. $fruits[0] .»
«; echo «Второй элемент массива — «. $fruits[1] .»
«; echo «Третий элемент массива — «. $fruits[2] .»
«;

Результатом выполнения программы будет:

php объявление массива пример

Важно: В качестве индекса элемента в ассоциативном массиве может быть не число, а слово (тип string)

Пример: Создать массив student со значениями имен, фамилий и возраста студентов. Вывести на экран значения элементов массива

1 2 3 4 5 6 7 8
$student = array( 'Name' => John, 'Surname' => Smith, 'Age' => 20 ); echo "имя пользователя " . $student['Name'] . "
"
; echo "фамилия пользователя " . $student['Surname'] . "
"
; echo "возраст пользователя " . $student['Age'] . "
"
;

$student = array( ‘Name’ => John, ‘Surname’ => Smith, ‘Age’ => 20 ); echo «имя пользователя » . $student[‘Name’] . «
«; echo «фамилия пользователя » . $student[‘Surname’] . «
«; echo «возраст пользователя » . $student[‘Age’] . «
«;

1 2 3 4 5 6
$student['Name'] = 'John'; $student['Surname'] = 'Smith'; $student['Age'] = 20; echo "имя пользователя " . $student['Name'] . "
"
; echo "фамилия пользователя " . $student['Surname'] . "
"
; echo "возраст пользователя " . $student['Age'] . "
"
;

$student[‘Name’] = ‘John’; $student[‘Surname’] = ‘Smith’; $student[‘Age’] = 20; echo «имя пользователя » . $student[‘Name’] . «
«; echo «фамилия пользователя » . $student[‘Surname’] . «
«; echo «возраст пользователя » . $student[‘Age’] . «
«;

вывод значений элементов массива в php пример

Важно: Строковые ключи (индексы) нужно всегда заключать в кавычки

Индексированные массивы без ключа:

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

$student = array('John','Smith', 20);

$student = array(‘John’,’Smith’, 20);

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

Пример преобразования типов и перезаписи элементов.
Обратите внимание на использование процедуры var_dump()

1 2 3 4 5 6 7 8 9
 $my_array = array( 0 => "a", "1"=> "b", 2 => "c", 2 => "d", ); var_dump($my_array); ?>
array(3) < [0]=>string(1) "a" [1]=> string(1) "b" [2]=> string(1) "d" >

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

1 2 3 4 5 6 7 8 9 10 11 12
 $array_odnom = array( "first" => "1", 2 => 2, "multi" => array( "1_1" => "1_1" ) ); var_dump($array_odnom ["first"]); var_dump($array_odnom [2]); var_dump($array_odnom ["multi"]["1_1"]); ?>

«1», 2 => 2, «multi» => array( «1_1» => «1_1» ) ); var_dump($array_odnom [«first»]); var_dump($array_odnom [2]); var_dump($array_odnom [«multi»][«1_1»]); ?>

string(1) "1" int(2) string(3) "1_1"

Пример: создать двумерный массив размерностью 3 х 2. Заполнить его значениями для первой строки: «1_1», «1_2», «1_3»; для второй строки: «2_1», «2_2», «2_3». Вывести на экран первый элемент массива

Выполнение:

1 2 3 4 5 6 7 8 9 10 11 12
$array_odnom = array( 1 => array( 1 => "1_1", 2 => "1_2", 3 => "1_3"), 2 => array( 1 => "2_1", 2 => "2_2", 3 => "2_3"), ); echo $array_odnom[1][1];

$array_odnom = array( 1 => array( 1 => «1_1», 2 => «1_2», 3 => «1_3»), 2 => array( 1 => «2_1», 2 => «2_2», 3 => «2_3»), ); echo $array_odnom[1][1];

Задание php2_1: создайте двумерный массив 3 х 3 — верхний левый угол таблицы умножения Пифагора(1, 2, 3; 4, 6, 8 …)

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

Используйте шаблон объявления и ориентируйтесь по цветам:

Красным – массивы.
Коричневым – числовая переменная.
Синим – константа.

Уважаемый (ая), Иван Иванович !
Приглашаем Вас на день открытых дверей .
Дата события: 12 мая.
С уважением, Василий.

Дополните код:

1 2 3 4 5 6 7 8 9 10 11 12 13 14
// объявление константы define("SIGN","С уважением, Вася"); // массив для имен адресатов $names = array(. ); // массив для событий $events = array( "op_doors" => "день открытых дверей", "vistavka" => "выставку", . ); $str = "Уважаемый(ая), $names[0]! 
"
; $str .= . ; $str .= . ; echo . ;

// объявление константы define(«SIGN»,»С уважением, Вася»); // массив для имен адресатов $names = array(. ); // массив для событий $events = array( «op_doors» => «день открытых дверей», «vistavka» => «выставку», . ); $str = «Уважаемый(ая), $names[0]!
«; $str .= . ; $str .= . ; echo . ;

Для того чтобы стать настоящим гуру в области программирования работы с API ВКОНТАКТЕ предлагаем пройти добротный и очень подробный видеокурс по PHP: работа с вконтакте. Замечательная, очень понятная форма подачи материала, пошаговость и доступные примеры гарантируют успешное усвоение и получение необходимых навыков. Подробно о курсе можно ознакомиться Для приобретения курса пройдите по . —>

Объявить пустой массив php?

Как объявить пустой массив?
если $arr = array();
то заполнение начнется с индекса 1($arr[1]).
Можно так:
$arr = array();
unset($arr[0]);
но как это сделать правильнее и проще?

  • Вопрос задан более трёх лет назад
  • 23447 просмотров

2 комментария

Оценить 2 комментария

e_svirsky

с чего это вы интересно взяли что заполнение начнётся с индекса 1 в первом случае?
не нужно тянуть сюда паскаль
Решения вопроса 1

littleguga

littleguga @littleguga
Не стыдно не знать, а стыдно не интересоваться.
Вы ошибаетесь — заполнение идет с 0 индекса.(по ссылке fiddle)

$arr = array(); array_push($arr, "test"); print_r($arr);

Сами проверьте, вот здесь, например.
Ответ написан более трёх лет назад
Комментировать
Нравится 1 Комментировать
Ответы на вопрос 2

danil_sport

Danil Akhtarov @danil_sport
Web, android, C++
PHP.нет посмотри тут. В свое время помогло
Ответ написан более трёх лет назад
Комментировать
Нравится Комментировать

elevenelven

Alex Safonov @elevenelven
Php Dev @ Amadeus
Это описывается в руководстве.
php.net/manual/en/function.array.php

 'January', 'February', 'March'); print_r($firstquarter); ?>

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

$array = [1,2,3]; array_unshift($array, '' ); unset($array[0]);

Ответ написан более трёх лет назад
Михаил @Madfisht3 Автор вопроса

Нужно пустой массив объявить. Чтобы там не было элементов. Объявить, но так, чтоб он был не инициализирован.

Алексей Объявляйте массив как обычно (array() или []). При добавлении в массив указываете нужный ключ ($arr[1] = 3.14)

Михаил @Madfisht3 Автор вопроса

krypt3r: а если у меня заполнение идёт через array_push? Тогда у меня первый элемент будет пустой, на сайте это лишняя строчка пустая.

Михаил @Madfisht3 Автор вопроса
Neoline: 500 Ошибка.
Михаил @Madfisht3 Автор вопроса
Второй листинг эквивалентен unset($arr[0])

elevenelven

Alex Safonov @elevenelven

Алексей: Будьте добры, приведите полностью код который эквивалентен второму листингу. Я думаю вы не имеете ввиду

$arr = array(); unset($arr[0]); array_push($arr, 1);

vadimkot

Алексей: вы каким то не тем php пользуетесь — при инициализации массива в него никакие элементы не добавляются и если выполнить array_push() после инициализации, то в массиве появится элемент с индексом 0.

Массивы

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

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

Курс PHP для начинающих

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

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

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

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

Курс 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);.

Курс PHP для начинающих

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

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

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

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

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

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

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

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

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

Курс PHP для начинающих

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

Во всех примерах, рассматриваемых до сих пор, массивы были одномерными, поскольку ключи, заданные в фигурных скобках, определяли только один уровень доступа к массиву. Но язык 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 для начинающих

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

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

Простые 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

Курс PHP для начинающих

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

Операция удаления элемента из массива является простой и полностью аналогичной операции удаления значения, присвоенного переменной. Достаточно просто вызвать функцию 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 не обязательно должны быть числовыми.)

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

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

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

В языке 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 появляется возможность легко эмулировать с помощью массивов такие структуры данных, как стеки и очереди. В языке PHP предусмотрены некоторые функции работы с массивами, специально предназначенные для этой цели. Если в программе используются исключительно такие функции, то программист может даже не учитывать, что в основе рассматриваемых структур данных лежат массивы.

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

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

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

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

Курс PHP для начинающих

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

Наконец, в языке 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().

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *