Как работает foreach php

Цикл foreach в PHP

Всем привет! В прошлом уроке мы с вами изучили основы массивов в PHP. Как вы уже поняли, массив может иметь довольно много элементов, и каждый из этих элементов, в свою очередь, также может являться массивом. Само собой, напрашивается вопрос: «А можно ли как-то автоматизировать обход по массиву?». То есть обращаться к его элементам по одному, не указывая при этом индексы значений. Ответ – можно. Для этого в PHP есть такая замечательная вещь, как циклы.

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

$carsSpeeds = [ 95, 140, 78 ];

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

$averageSpeed = ($carsSpeeds[0] + $carsSpeeds[1] + $carsSpeeds[2]) / 3;

Простейшая школьная математика. Однако, если представить, что таких значений в массиве будет хотя бы 10, это уже приведёт к значительному разрастанию выражения. На помощь нам приходят циклы в PHP.

• Тест на знание основ HTML
• Тест на знание основ PHP
• Тест на знание ООП в PHP

Рассмотрим в первую очередь языковую конструкцию foreach (от английского for – для, each — каждый). Она позволяет пройтись по каждому элементу массива. Она просто проходит по каждому элементу массива по очереди и позволяет выполнить с ним какое-либо действие.
Использование конструкции выглядит следующим образом:

foreach ($array as $index => $value)

где $array – это массив, $index и $value – это индекс и значение элемента на текущем шаге соответственно. Они на каждом новом элементе просто изменяют свои значения. Переменные $index и $value определяются прямо здесь, их раньше могло не существовать, они определяются прямо в процессе обхода массива.

То, что находится внутри фигурных скобок будет повторяться для каждого элемента массива. Один такой проход называется шагом или итерацией. Один элемент = одна итерация. Запомните это слово.
Цикл будет идти по массиву, пока не закончатся все элементы. Затем программа продолжит своё выполнение.

• Тест на знание основ HTML
• Тест на знание основ PHP
• Тест на знание ООП в PHP

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

 $speed) < echo $index . ' ' . $speed . '
'; >

0 95 1 140 2 78

Как мы видим, на первом шаге цикла в переменные $index и $speed попали значения 0 и 95 соответственно. На втором – 1 и 140 и так далее. Всё как мы и ожидали. Было выполнено 3 итерации.

Если нам не нужны индексы массива, то их можно не указывать в этой конструкции:

foreach ($array as $value)

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

Вернёмся к задаче

Итак, нам нужно найти среднюю скорость. Для этого нам нужно:

1. сложить все значения скоростей
2. поделить получившуюся сумму на кол-во значений

Для того, чтобы выполнить первый шаг, давайте прибегнем к помощи цикла foreach:

 echo $sumOfSpeeds;

Перед началом цикла определили переменную $sumOfSpeeds равную 0, а затем на каждой итерации прибавляли к ней значения скоростей. В конце просто вывели получившийся результат, который равен 313. Можете проверить на калькуляторе.

Теперь нужно разделить получившееся значение на число элементов.

Чтобы узнать число элементов в массиве можно прибегнуть к функции count($carSpeeds) – на вход передаётся имя массива. Полностью наш код будет выглядеть следующим образом:

 $countOfCars = count($carsSpeeds); $averageSpeed = $sumOfSpeeds / $countOfCars; echo 'Средняя скорость движения по трассе: ' . $averageSpeed;

На этом всё. Всем пока!

foreach

Конструкция foreach предоставляет простой способ перебора массивов. Foreach работает только с массивами и объектами, и будет генерировать ошибку при попытке использования с переменными других типов или неинициализированными переменными. Существует два вида синтаксиса:

foreach (array_expression as $value) statement foreach (array_expression as $key => $value) statement

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

Второй цикл будет дополнительно соотносить ключ текущего элемента с переменной $key на каждой итерации.

Замечание:

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

Так как оператор foreach опирается на внутренний указатель массива, его изменение внутри цикла может привести к непредсказуемому поведению.

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

$arr = array( 1 , 2 , 3 , 4 );
foreach ( $arr as & $value ) $value = $value * 2 ;
>
// массив $arr сейчас таков: array(2, 4, 6, 8)
unset( $value ); // разорвать ссылку на последний элемент
?>

Указатель на $value возможен, только если на перебираемый массив можно ссылаться (т.е. если он является переменной). Следующий код не будет работать:

foreach (array( 1 , 2 , 3 , 4 ) as & $value ) $value = $value * 2 ;
>
?> Внимание

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

Замечание:

Оператор foreach не поддерживает возможность подавления сообщений об ошибках с помощью префикса ‘@’.

Вы могли заметить, что следующие конструкции функционально идентичны:

$arr = array( «one» , «two» , «three» );
reset ( $arr );
while (list(, $value ) = each ( $arr )) echo «Значение: $value
\n» ;
>

foreach ( $arr as $value ) echo «Значение: $value
\n» ;
>
?>

Следующие конструкции также функционально идентичны:

$arr = array( «one» , «two» , «three» );
reset ( $arr );
while (list( $key , $value ) = each ( $arr )) echo «Ключ: $key ; Значение: $value
\n» ;
>

foreach ( $arr as $key => $value ) echo «Ключ: $key ; Значение: $value
\n» ;
>
?>

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

$a = array( 1 , 2 , 3 , 17 );

foreach ( $a as $v ) echo «Текущее значение переменной \$a: $v .\n» ;
>

/* Пример 2: значение (для иллюстрации массив выводится в виде значения с ключом) */

$a = array( 1 , 2 , 3 , 17 );

$i = 0 ; /* только для пояснения */

foreach ( $a as $v ) echo «\$a[ $i ] => $v .\n» ;
$i ++;
>

/* Пример 3: ключ и значение */

$a = array(
«one» => 1 ,
«two» => 2 ,
«three» => 3 ,
«seventeen» => 17
);

foreach ( $a as $k => $v ) echo «\$a[ $k ] => $v .\n» ;
>

/* Пример 4: многомерные массивы */
$a = array();
$a [ 0 ][ 0 ] = «a» ;
$a [ 0 ][ 1 ] = «b» ;
$a [ 1 ][ 0 ] = «y» ;
$a [ 1 ][ 1 ] = «z» ;

foreach ( $a as $v1 ) foreach ( $v1 as $v2 ) echo » $v2 \n» ;
>
>

/* Пример 5: динамические массивы */

foreach (array( 1 , 2 , 3 , 4 , 5 ) as $v ) echo » $v \n» ;
>
?>

Распаковка вложенных массивов с помощью list()

(PHP 5 >= 5.5.0, PHP 7)

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

foreach ( $array as list( $a , $b )) // $a содержит первый элемент вложенного массива,
// а $b содержит второй элемент.
echo «A: $a ; B: $b \n» ;
>
?>

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

A: 1; B: 2 A: 3; B: 4

Можно передавать меньшее количество элементов в list() , чем находится во вложенном массиве, в этом случае оставшиеся значения массива будут проигнорированы:

foreach ( $array as list( $a )) // Обратите внимание на отсутствие $b.
echo » $a \n» ;
>
?>

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

Если массив содержит недостаточно элементов для заполнения всех переменных из list() , то будет сгенерировано замечание об ошибке:

foreach ( $array as list( $a , $b , $c )) echo «A: $a ; B: $b ; C: $c \n» ;
>
?>

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

Notice: Undefined offset: 2 in example.php on line 7 A: 1; B: 2; C: Notice: Undefined offset: 2 in example.php on line 7 A: 3; B: 4; C:

PHP: Перебор элементов массива

Цикл foreach осуществляет последовательный перебор всех элементов массива. Он работает только с массивами и объектами, а в случае его использования с переменными других типов или неинициализированными переменными будет сгенерирована ошибка.

Есть два вида синтаксиса для данного цикла. Первый вид синтаксиса цикла foreach выглядит следующим образом:

foreach ($array as $value)

Цикл будет перебирать заданный массив — $array (вместо $array подставляется название массива). На каждой итерации значение текущего элемента присваивается переменной $value (можно указать любое другое имя переменной).

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

Посмотрим, как он работает на примере:

Второй вид синтаксиса foreach , выглядит так:

foreach ($array as $key => $value)

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

 $value) < echo "[$key] =>", $value, "
"; > ?>

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

 /* это нужно для того, чтобы последующие записи в переменную $value не меняли последний элемент массива */ unset($value); // разорвать ссылку на последний элемент ?>

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

 // Присваиваем новое значение переменной $num $num = '100'; echo '
'; foreach ($numbers as &$num) < echo $num, " "; >?>

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

С этой темой смотрят:

• Числовые массивы
• Ассоциативные массивы
• Добавление и удаление элементов массива
• Многомерные массивы
• break, continue и goto

Копирование материалов с данного сайта возможно только с разрешения администрации сайта
и при указании прямой активной ссылки на источник.
2011 – 2023 © puzzleweb.ru | razumnikum.ru

О тонкостях работы foreach в PHP

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

Внимание: этот текст подразумевает наличие базовых знаний о функциональности zval’ов в PHP, в частности вы должны знать что такое refcount и is_ref.
foreach работает с сущностями разных типов: с массивами, с простыми объектами (где перечисляются доступные свойства) и с Traversable-объектами (вернее, объектами, у которых определен внутренний обработчик get_iterator). Здесь мы, в основном, говорим о массивах, но я скажу и об остальных в самом конце.

Прежде чем приступить, пара слов о массивах и их обходе, важная для понимания контекста.

Как работает обход массивов

Массивы в PHP являются упорядоченными хеш-таблицами (элементы хеша объединены в двусвязный список) и foreach обходит массив, следуя указанному порядку.

• Первый способ — внутренний указатель массива. Этот указатель является частью структуры HashTable и представляет собой просто указатель на текущий элемент хеш-таблицы. Внутренний указатель массива можно безнаказанно изменять, то есть если текущий элемент удалён, внутренний указатель массива будет перемещен на следующий.
• Второй механизм итерации — внешний указатель массива, под названием HashPosition. Это практически то же самое, что и внутренний указатель массива, но он не является частью HashTable. Этот внешний способ итерации не безопасен к изменениям. Если вы удалите элемент, на который указывает HashPosition, то останетесь с висячим указателем, что приведёт к ошибке сегментации.

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

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

Простой пример, показывающий важность копирования (кстати, не такая большая редкость), это вложенная итерация:

foreach ($array as $a) < foreach ($array as $b) < // . >> 

Здесь вы хотите чтобы оба цикла были независимым, а не хитро перебрасывались одним указателем.

Итак, мы дошли до foreach.

Обход массива в foreach

Теперь вы знаете, для чего foreach приходится создавать копию массива, прежде чем обойти его. Но это явно не вся история. Сделает PHP копию или нет, зависит от нескольких факторов:

Если итерируемый массив является ссылкой, копирования не произойдёт, вместо этого будет выполнен addref:

$ref =& $array; // $array has is_ref=1 now foreach ($array as $val) < // . >

Итак, это первая часть тайны: функция копирования. Вторая часть это то, как текущая итерация выполняется, и она тоже довольно странная. «Обычный» образец итерации, который вы уже знаете (и который часто используется в PHP — отдельно от foreach) выглядит примерно так (псевдокод):

reset(); while (get_current_data(&data) == SUCCESS)

итерация foreach выглядит немного иначе:

reset(); while (get_current_data(&data) == SUCCESS)

Отличие в том, что move_forward() выполняется в начале, а не в конце цикла. Таким образом, когда код пользователя использует элемент $i, внутренний указатель массива уже указывает на элемент $i+1.

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

Последствия для кода

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

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

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

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

А сейчас вернёмся к вашим примерам:

foreach ($array as $item) < echo "$item\n"; $array[] = $item; >print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 2 3 4 5 1 2 3 4 5 */ 

Здесь $array имеет refcount=1 до цикла, так что он не будет копирован, но получит addref. Как только вы присвоите значение $array[], zval будет разделен, так что массив, к которому вы добавляете элементы и итерируемый массив будут двумя разными массивами.

foreach ($array as $key => $item) < $array[$key + 1] = $item + 2; echo "$item\n"; >print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 3 4 5 6 7 */ 

Та же ситуация, что и в первом тесте.

// Сдвигаем указатель на единицу, чтобы убедиться, что это не влияет на foreach var_dump(each($array)); foreach ($array as $item) < echo "$item\n"; >var_dump(each($array)); /* Output array(4) < [1]=>int(1) ["value"]=> int(1) [0]=> int(0) ["key"]=> int(0) > 1 2 3 4 5 bool(false) */ 

Снова та же история. Во время цикла foreach, у вас refcount=1 и вы получаете только addref, внутренний указатель $array будет изменён. В конце цикла указатель становится NULL (это означает что итерация закончена). each демонстрирует это, возвращая false.

foreach ($array as $key => $item) < echo "$item\n"; each($array); >/* Output: 1 2 3 4 5 */ 

foreach ($array as $key => $item) < echo "$item\n"; reset($array); >/* Output: 1 2 3 4 5 */ 

Функции each и reset обе обращаются по ссылке. $array имеет refcount=2 когда доходит до них, в результате чего он должен быть разделен. Снова foreach сработает на отдельном массиве.

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

foreach ($array as $val) < var_dump(current($array)); >/* Output: 2 2 2 2 2 */ 

Здесь вы должны иметь в виду, что current тоже обращается по ссылке, несмотря на то, что не изменяет массив. Это нужно, чтобы согласованно работать со всеми остальными функциями, вроде next, которые обращаются по ссылке (current, вообще-то, предпочтительно-ref функция; она может получить значение, но использует ссылку, если сможет). Ссылка означает, что массив должен быть отделён, следовательно, $array и копия $array, которую использует foreach, будут независимы. Почему вы получаете 2, а не 1, также упомянуто выше: foreach увеличивает указатель массива до начала кода пользователя, а не после. Так что, даже если код все еще работает с первым элементом, foreach уже переместил указатель ко второму.

Теперь попробуем сделать небольшое изменение:

$ref = &$array; foreach ($array as $val) < var_dump(current($array)); >/* Output: 2 3 4 5 false */ 

Здесь у нас is_ref=1, так что массив не копирован (так как и выше). Но сейчас когда есть is_ref, массив больше не нужно разделять, передавая по ссылке к current. Теперь current и foreach работают с одним массивом. Вы видите массив сдвинутым на единицу как раз из-за того, как foreach обращается с указателем.

То же самое вы увидите, когда будете делать обход массива по ссылкам:

foreach ($array as &$val) < var_dump(current($array)); >/* Output: 2 3 4 5 false */ 

Здесь самое важное — то, что foreach назначит нашему $array is_ref=1, когда он будет обходить его в цикле по ссылке, так что получится то же, что и выше.

Еще одна небольшая вариация, здесь мы присвоим наш массив еще одной переменной:

$foo = $array; foreach ($array as $val) < var_dump(current($array)); >/* Output: 1 1 1 1 1 */ 

Здесь refcount массива $array принимает значение 2, когда цикл начался, так что нужно сделать копию, прежде чем начинать. Таким образом, $array и массив используемый foreach будут разными с самого начала. Вот почему вы получаете ту позицию внутреннего указателя массива, которая была актуальна до начала цикла (в этом случае он был в первой позиции).

Итерация объектов

При итерации объектов имеет смысл рассмотреть два случая:

Объект не Traversable (вернее, не определен внутренний обработчик get_iterator)

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

• Для объявленных свойств PHP реоптимизирует хеш-таблицу свойств. Если вы все-таки итерируете объект, он должен реконструировать эту хеш-таблицу (что повышает использование памяти). Не то, чтобы вам следовало беспокоиться об этом, просто имейте в виду.
• На каждой итерации хеш-таблица свойств будет получена заново, то есть PHP будет вызывать get_properties снова, и снова, и снова. Для «обычных» свойств это не так важно, но если свойства создаются динамически (это часто делают встроенные классы) — то таблица свойств будет пересчитываться каждый раз.

Объект Traversable

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

Замена итерируемого объекта во время цикла

Другой необычный случай, который я не упомянул — PHP допускает возможность замены итерируемого объекта во время цикла. Вы можете начать с одним массивом и продолжить, заменив его на полдороге другим. Или начать с массивом, в затем заменить его объектом:

$arr = [1, 2, 3, 4, 5]; $obj = (object) [6, 7, 8, 9, 10]; $ref =& $arr; foreach ($ref as $val) < echo "$val\n"; if ($val == 3) < $ref = $obj; >> /* Output: 1 2 3 6 7 8 9 10 */ 

Как видите, PHP просто начал обходить другую сущность, как только произошла замена.

Изменение внутреннего указателя массива во время итерации

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

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

Давайте посмотрим что означает «попытается». Первый пример показывает, как изменение внутреннего указателя не меняет режим foreach:

$array = [1, 2, 3, 4, 5]; $ref =& $array; foreach ($array as $value) < var_dump($value); reset($array); >// output: 1, 2, 3, 4, 5 

Теперь давайте попробуем сделать unset элементу, к которому обратится foreach при первом проходе (ключ 1):

$array = [1, 2, 3, 4, 5]; $ref =& $array; foreach ($array as $value) < var_dump($value); unset($array[1]); reset($array); >// output: 1, 1, 3, 4, 5 

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

Имейте в виду, хеш — всего лишь хеш. Случаются коллизии. Попробуем теперь так:

$array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3]; $ref =& $array; foreach ($array as $value) < unset($array['EzFY']); $array['FYFZ'] = 4; reset($array); var_dump($value); >// output: 1 1 3 4 

Работает так, как мы и ожидали. Мы удалили ключ EzFY (тот, где как раз был foreach), так что был сделан сброс. Также мы добавили дополнительный ключ, поэтому в конце мы видим 4.

И вот тут приходит неведомое. Что произойдёт, если заменить ключ FYFY с FYFZ? Давайте попробуем:

$array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3]; $ref =& $array; foreach ($array as $value) < unset($array['EzFY']); $array['FYFY'] = 4; reset($array); var_dump($value); >// output: 1 4 

Сейчас цикл перешёл непосредственно к новому элементу, пропуская всё остальное. Это потому что ключ FYFY имеет коллизию с EzFY (вообще-то, все ключи из этого массива тоже). Более этого, элемент FYFY находится по тому же адресу в памяти, что и элемент EzFY который только что был удален. Так что для PHP это будет та же самая позиция с тем же хешом. Позиция «восстановлена» и происходит переход к концу массива.