Вопрос: Как работает PHP foreach?


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


Долгое время я предполагал, что foreachработал с самим массивом. Затем я нашел много ссылок на то, что он работает с копия из массива, и я с тех пор полагаю, что это конец истории. Но я недавно занялся обсуждением этого вопроса, и после небольшого эксперимента выяснилось, что это на самом деле не на 100% верно.

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

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

Тестовый корпус 1 :

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 */

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

Тестовый корпус 2 :

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 сначала запускает выполнение, внутренний указатель массива автоматически возвращается к первому элементу массива.

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

Тестовый корпус 3 :

// Move the array pointer on one to make sure it doesn't affect the loop
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)
*/

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

Руководство PHP также гласит:

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

Ну, давайте узнаем, что такое «неожиданное поведение» (технически, любое поведение неожиданно, так как я больше не знаю, чего ожидать).

Тестовый корпус 4 :

foreach ($array as $key => $item) {
  echo "$item\n";
  each($array);
}

/* Output: 1 2 3 4 5 */

Тестовый корпус 5 :

foreach ($array as $key => $item) {
  echo "$item\n";
  reset($array);
}

/* Output: 1 2 3 4 5 */

... ничего неожиданного там, на самом деле, похоже, поддерживает теорию «копий источника».


Вопрос

Что здесь происходит? Мой C-fu недостаточно хорош для того, чтобы я мог извлечь правильный вывод, просто взглянув на исходный код PHP, я был бы признателен, если бы кто-то мог перевести его на английский для меня.

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

  • Это правильно и вся история?
  • Если нет, что это на самом деле делает?
  • Есть ли ситуация, когда используются функции, которые регулируют указатель массива ( each(), reset()и др.) во время foreachможет повлиять на результат цикла?

1619


источник


Ответы:


foreachподдерживает итерацию по трем различным типам значений:

  • Массивы
  • Обычные объекты
  • Traversableобъекты

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

foreach ($it as $k => $v) { /* ... */ }

/* translates to: */

if ($it instanceof IteratorAggregate) {
    $it = $it->getIterator();
}
for ($it->rewind(); $it->valid(); $it->next()) {
    $v = $it->current();
    $k = $it->key();
    /* ... */
}

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

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

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

Все идет нормально. Итерация по словарю не может быть слишком сложной, не так ли? Проблемы начинаются, когда вы понимаете, что массив / объект может меняться во время итерации. Это может произойти несколькими способами:

  • Если вы перебираете по ссылке, используя foreach ($arr as &$v)тогда $arrпревращается в ссылку, и вы можете изменить ее во время итерации.
  • В PHP 5 то же самое применяется, даже если вы итерации по значению, но массив был ссылкой заранее: $ref =& $arr; foreach ($ref as $v)
  • Объекты имеют сквозную семантику по-методу, которая для практических целей означает, что они ведут себя как ссылки. Таким образом, объекты всегда могут быть изменены во время итерации.

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

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

Как последнее предварительное, следует отметить, что PHP использует подсчет ссылок и копирование на запись для управления памятью. Это означает, что если вы «скопируете» значение, вы фактически просто повторно используете старое значение и увеличиваете его счетчик ссылок (refcount). Только после выполнения какой-либо модификации будет выполнена реальная копия (называемая «дублированием»). Видеть Тебя солгали для более широкого введения в эту тему.

PHP 5

Внутренний указатель массива и HashPointer

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

В то время как foreach использует IAP, существует дополнительное усложнение: существует только один IAP, но один массив может быть частью нескольких циклов foreach:

// Using by-ref iteration here to make sure that it's really
// the same array in both loops and not a copy
foreach ($arr as &$v1) {
    foreach ($arr as &$v) {
        // ...
    }
}

Для поддержки двух одновременных циклов только с одним внутренним указателем массива foreach выполняет следующие сценарии: до того, как тело цикла будет выполнено, foreach вернет указатель на текущий элемент и его хэш в pere-foreach HashPointer, После того, как тело цикла будет запущено, IAP будет возвращен к этому элементу, если он все еще существует. Однако, если элемент был удален, мы будем использовать только то, что сейчас находится в IAP. Эта схема в основном-kinda-sortof работает, но есть много странного поведения, из-за которого вы можете избавиться, некоторые из которых я продемонстрирую ниже.

Дублирование массива

IAP - видимая особенность массива (отображается через currentсемейство функций), так как такие изменения в IAP считаются модификациями в семантике copy-on-write. Это, к сожалению, означает, что foreach во многих случаях вынуждает дублировать массив, который он итерирует. Точные условия:

  1. Массив не является ссылкой (is_ref = 0). Если это ссылка, то изменения в ней предполагаемый для распространения, поэтому его не следует дублировать.
  2. Массив имеет refcount> 1. Если refcount равен 1, массив не используется, и мы можем свободно его изменять.

Если массив не дублируется (is_ref = 0, refcount = 1), то только его refcount будет увеличиваться (*). Кроме того, если используется foreach по ссылке, то (потенциально дублированный) массив будет превращен в ссылку.

Рассмотрим этот код как пример, где происходит дублирование:

function iterate($arr) {
    foreach ($arr as $v) {}
}

$outerArr = [0, 1, 2, 3, 4];
iterate($arr);

Вот, $arrбудет дублироваться, чтобы предотвратить изменения IAP на $arrот утечки до $outerArr, В терминах вышеприведенных условий массив не является ссылкой (is_ref = 0) и используется в двух местах (refcount = 2). Это требование является неудачным и является артефактом субоптимальной реализации (здесь нет никакой модификации во время итерации, поэтому нам действительно не нужно использовать IAP в первую очередь).

(*) Инкремент пересчета здесь звучит безобидно, но нарушает семантику copy-on-write (COW): это означает, что мы собираемся изменить IAP массива refcount = 2, в то время как COW диктует, что изменения могут быть выполнены только при пересчете = 1. Это нарушение приводит к изменению поведения пользователя (в то время как COW обычно прозрачен), поскольку изменение IAP в итерированном массиве будет наблюдаемым - но только до первой модификации, отличной от IAP в массиве. Вместо этого тремя «действительными» параметрами были бы: а) чтобы всегда дублировать, b) чтобы не увеличивать коэффициент пересчета и, таким образом, позволяя произвольно модифицировать итерированный массив в цикле или в) вообще не использовать IAP ( решение для PHP 7).

Порядок продвижения позиции

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

reset(arr);
while (get_current_data(arr, &data) == SUCCESS) {
    code();
    move_forward(arr);
}

Однако foreach, будучи довольно особой снежинкой, предпочитает делать вещи несколько иначе:

reset(arr);
while (get_current_data(arr, &data) == SUCCESS) {
    move_forward(arr);
    code();
}

А именно, указатель массива уже перемещен вперед до тело цикла работает. Это означает, что, хотя тело цикла работает с элементом $i, IAP уже находится в элементе $i+1, Именно по этой причине образцы кода, отображающие модификацию во время итерации, всегда будут следующий элемент, а не текущий.

Примеры: ваши тестовые примеры

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

Поведение ваших тестовых случаев просто объяснить на данный момент:

  • В тестовых случаях 1 и 2 $arrayначинается с refcount = 1, поэтому он не будет дублироваться foreach: увеличивается только показатель refcount. Когда тело цикла впоследствии изменяет массив (который имеет refcount = 2 в этой точке), дублирование произойдет в этой точке. Foreach продолжит работу над немодифицированной копией $array,

  • В тестовом примере 3 еще раз массив не дублируется, поэтому foreach будет изменять IAP $arrayпеременная. В конце итерации IAP имеет значение NULL (что означает итерацию), которая eachуказывает, возвращаясь false,

  • В тестовых случаях 4 и 5 оба eachа также resetявляются опорными функциями. $arrayимеет refcount=2когда он передается им, поэтому его нужно дублировать. Как таковой foreachснова будет работать над отдельным массивом.

Примеры: Эффекты currentв foreach

Хорошим способом показать различные способы дублирования является наблюдение за поведением current()функция внутри цикла foreach. Рассмотрим этот пример:

foreach ($array as $val) {
    var_dump(current($array));
}
/* Output: 2 2 2 2 2 */

Здесь вы должны знать, что current()является функцией ref-ref (фактически: prefer-ref), хотя она не модифицирует массив. Это должно быть для того, чтобы играть хорошо со всеми другими функциями, такими как nextкоторые все включены. Прохождение байтов означает, что массив должен быть разделен и, следовательно, $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, поэтому массив не копируется (как и выше). Но теперь, когда это ссылка, массив больше не должен дублироваться при передаче по ссылке current()функция. таким образом current()и foreach работают над одним и тем же массивом. Тем не менее, вы по-прежнему видите поведение по отдельности, из-за того, что foreachпродвигает указатель.

При выполнении повторной итерации вы получаете такое же поведение:

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

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

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

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

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

Примеры: изменение во время итерации

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

Рассмотрим эти вложенные петли над одним и тем же массивом (где by-ref итерация используется, чтобы убедиться, что она действительно одна и та же):

foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Output: (1, 1) (1, 3) (1, 4) (1, 5)

Ожидаемая часть здесь состоит в том, что (1, 2)отсутствует на выходе, потому что элемент 1был удален. Вероятно, неожиданным является то, что внешний цикл останавливается после первого элемента. Почему это?

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

Еще одно следствие HashPointerмеханизм резервного копирования + восстановления - это то, что изменения в IAP, хотя reset()и т. д. обычно не влияют на foreach. Например, следующий код выполняется так, как если бы reset()вообще отсутствовали:

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

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

$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

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

$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

Здесь мы обычно должны ожидать выхода 1, 1, 3, 4в соответствии с предыдущими правилами. Как происходит то, что 'FYFY'имеет тот же хеш, что и удаленный элемент 'EzFY', и распределитель используется для повторного использования одного и того же места памяти для хранения элемента. Таким образом, foreach попадает прямо к вновь вставленному элементу, тем самым сокращая петлю.

Подстановка повторяющегося объекта во время цикла

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

PHP 7

Итераторы Hashtable

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

PHP 7 использует другой подход, а именно поддерживает произвольное количество внешних, безопасных итераторов хэш-таблицы. Эти итераторы должны быть зарегистрированы в массиве, откуда они имеют одинаковую семантику, как и IAP: если элемент массива удален, все итераторы хеш-таблицы, указывающие на этот элемент, будут переходить к следующему элементу.

Это означает, что foreach больше не будет использовать IAP вообще , Цикл foreach абсолютно не влияет на результаты current()и т. д., и его собственное поведение никогда не будет влиять на функции, подобные reset()и т.п.

Дублирование массива

Еще одно важное изменение между PHP 5 и PHP 7 связано с дублированием массива. Теперь, когда IAP больше не используется, итерация массива по-величине будет делать только приращение refcount (вместо дублирования массива) во всех случаях. Если массив изменен во время цикла foreach, в этот момент произойдет дублирование (в соответствии с копией на запись), и foreach продолжит работу над старым массивом.

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

$array = [1, 2, 3, 4, 5];
$ref = &$array;
foreach ($array as $val) {
    var_dump($val);
    $array[2] = 0;
}
/* Old output: 1, 2, 0, 4, 5 */
/* New output: 1, 2, 3, 4, 5 */

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

Это, конечно же, не относится к итерации ссылок. Если вы перечислите по ссылке, все изменения будут отражены в цикле. Интересно, что то же самое верно и для итерации с равными значениями простых объектов:

$obj = new stdClass;
$obj->foo = 1;
$obj->bar = 2;
foreach ($obj as $val) {
    var_dump($val);
    $obj->bar = 42;
}
/* Old and new output: 1, 42 */

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

Примеры

Давайте рассмотрим несколько примеров, начиная с ваших тестовых случаев:

  • Контрольные случаи 1 и 2 сохраняют один и тот же результат: итерация массива по-прежнему всегда работает с исходными элементами. (В этом случае даже пересчет и поведение дублирования точно совпадают между PHP 5 и PHP 7).

  • Тестовый случай 3 изменения: Foreach больше не использует IAP, поэтому each()не зависит от цикла. Он будет иметь тот же результат до и после.

  • Тесты 4 и 5 остаются неизменными: each()а также reset()будет дублировать массив перед изменением IAP, в то время как foreach все еще использует исходный массив. (Не то, чтобы изменение IAP имело значение, даже если массив был разделен.)

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

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

$array = [1, 2, 3, 4, 5];
foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Old output: (1, 1) (1, 3) (1, 4) (1, 5)
// New output: (1, 1) (1, 3) (1, 4) (1, 5)
//             (3, 1) (3, 3) (3, 4) (3, 5)
//             (4, 1) (4, 3) (4, 4) (4, 5)
//             (5, 1) (5, 3) (5, 4) (5, 5) 

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

Еще один странный краевой случай, который исправлен сейчас, - это нечетный эффект, который вы получаете, когда вы удаляете и добавляете элементы, которые имеют одинаковый хеш:

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

Ранее механизм восстановления HashPointer переместился прямо к новому элементу, потому что он «выглядел» так же, как и элемент remove (из-за встречного хэша и указателя). Поскольку мы больше не полагаемся на хэш элементов для чего-либо, это уже не проблема.


1361



В примере 3 вы не изменяете массив. Во всех других примерах вы изменяете либо содержимое, либо указатель внутреннего массива. Это важно, когда дело доходит до PHP массивов из-за семантики оператора присваивания.

Оператор присваивания для массивов в PHP работает скорее как ленивый клон. Присвоение одной переменной другому, содержащей массив, будет клонировать массив, в отличие от большинства языков. Однако фактическое клонирование не будет выполнено, если оно не понадобится. Это означает, что клон будет иметь место только при изменении одной из переменных (copy-on-write).

Вот пример:

$a = array(1,2,3);
$b = $a;  // This is lazy cloning of $a. For the time
          // being $a and $b point to the same internal
          // data structure.

$a[] = 3; // Here $a changes, which triggers the actual
          // cloning. From now on, $a and $b are two
          // different data structures. The same would
          // happen if there were a change in $b.

Возвращаясь к вашим тестовым примерам, вы можете легко представить, что foreachсоздает своего рода итератор со ссылкой на массив. Эта ссылка работает точно так же, как переменная $bв моем примере. Однако итератор вместе со ссылкой действует только во время цикла, а затем они оба отбрасываются. Теперь вы можете видеть, что во всех случаях, но 3, массив изменяется во время цикла, в то время как эта дополнительная ссылка жива. Это вызывает клон, и это объясняет, что здесь происходит!

Вот отличная статья для другого побочного эффекта этого поведения при копировании на запись: Терминальный оператор PHP: быстрый или нет?


97



Некоторые моменты, которые следует учитывать при работе с foreach():

а) foreachработает над проверенная копия исходного массива.     Это означает, что foreach () будет хранить данные SHARED до или после prospected copyявляется     не создано foreach Примечания / Комментарии пользователей ,

б) Что вызывает проверенная копия ?     Проспективная копия создается на основе политики copy-on-write, т.е. когда     массив, переданный в foreach (), изменяется, создается клон исходного массива.

c) Идентификатор исходного массива и foreach () будет иметь DISTINCT SENTINEL VARIABLES, то есть один для исходного массива и другой для foreach; см. тестовый код ниже. SPL , итераторы , а также Итератор массива ,

Вопрос переполнения стека Как убедиться, что значение сбрасывается в цикле foreach в PHP? рассматривает дела (3,4,5) вашего вопроса.

В следующем примере показано, что каждый () и reset () не влияют SENTINELпеременные (for example, the current index variable)итератора foreach ().

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

list($key2, $val2) = each($array);
echo "each() Original (outside): $key2 => $val2<br/>";

foreach($array as $key => $val){
    echo "foreach: $key => $val<br/>";

    list($key2,$val2) = each($array);
    echo "each() Original(inside): $key2 => $val2<br/>";

    echo "--------Iteration--------<br/>";
    if ($key == 3){
        echo "Resetting original array pointer<br/>";
        reset($array);
    }
}

list($key2, $val2) = each($array);
echo "each() Original (outside): $key2 => $val2<br/>";

Вывод:

each() Original (outside): 0 => 1
foreach: 0 => 1
each() Original(inside): 1 => 2
--------Iteration--------
foreach: 1 => 2
each() Original(inside): 2 => 3
--------Iteration--------
foreach: 2 => 3
each() Original(inside): 3 => 4
--------Iteration--------
foreach: 3 => 4
each() Original(inside): 4 => 5
--------Iteration--------
Resetting original array pointer
foreach: 4 => 5
each() Original(inside): 0=>1
--------Iteration--------
each() Original (outside): 1 => 2

33



ПРИМЕЧАНИЕ ДЛЯ PHP 7

Чтобы обновить этот ответ, поскольку он приобрел некоторую популярность: этот ответ больше не применяется с PHP 7. Как объясняется в разделе " Обратные несовместимые изменения », в PHP 7 foreach работает над копией массива, поэтому любые изменения в самом массиве не отражаются в цикле foreach. Подробнее об этой ссылке.

Объяснение (цитата из php.net ):

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

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

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

Я считаю, что это все последствия На каждой итерации часть объяснения в документации, что, вероятно, означает, что foreachделает всю логику до вызова кода в {},

Прецедент

Если вы запустите это:

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        $array['baz']=3;
        echo $v." ";
    }
    print_r($array);
?>

Вы получите этот результат:

1 2 3 Array
(
    [foo] => 1
    [bar] => 2
    [baz] => 3
)

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

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        if ($k=='bar') {
            $array['baz']=3;
        }
        echo $v." ";
    }
    print_r($array);
?>

Ты получишь:

1 2 Array
(
    [foo] => 1
    [bar] => 2
    [baz] => 3
)

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

Подробное объяснение можно прочитать на Как работает PHP foreach? что объясняет внутренности, стоящие за этим поведением.


22



Согласно документации, предоставленной руководством PHP.

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

Итак, согласно вашему первому примеру:

$array = ['foo'=>1];
foreach($array as $k=>&$v)
{
   $array['bar']=2;
   echo($v);
}

$arrayимеют только один элемент, так как при выполнении foreach 1 назначают $vи у него нет другого элемента для перемещения указателя

Но в вашем втором примере:

$array = ['foo'=>1, 'bar'=>2];
foreach($array as $k=>&$v)
{
   $array['baz']=3;
   echo($v);
}

$arrayимеют два элемента, поэтому теперь $ array вычисляет нулевые индексы и перемещает указатель на единицу. Для первой итерации цикла добавлен $array['baz']=3;как пройти по ссылке.


8



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

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    echo "{$item}\n";
}

Эти результаты:

apple
banana
coconut

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

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $item = strrev ($item);
}

print_r($set);

Эти результаты:

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
)

Любые изменения от оригинала не могут быть отмечены, на самом деле никаких изменений с оригиналом не происходит, даже если вы явно присвоили значение $ item. Это связано с тем, что вы работаете над $ item, поскольку он отображается в копии $ set, над которым работает. Вы можете переопределить это, захватив $ item по ссылке, например:

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $item = strrev($item);
}
print_r($set);

Эти результаты:

Array
(
    [0] => elppa
    [1] => ananab
    [2] => tunococ
)

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

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $set[] = ucfirst($item);
}
print_r($set);

Эти результаты:

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
    [3] => Apple
    [4] => Banana
    [5] => Coconut
)

Как показано в примере, PHP скопировал $ set и использовал его для перебора, но когда в цикле был использован $ set, PHP добавил переменные в исходный массив, а не в скопированный массив. В принципе, PHP использует только скопированный массив для выполнения цикла и назначения $ item. Из-за этого цикл выше выполняется только 3 раза и каждый раз добавляет другое значение в конец исходного набора $, оставляя исходный $ set с 6 элементами, но никогда не вступая в бесконечный цикл.

Однако, что, если бы мы использовали $ item по ссылке, как я уже упоминал ранее? Один символ добавлен к вышеуказанному тесту:

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $set[] = ucfirst($item);
}
print_r($set);

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

ini_set("memory_limit","1M");

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


5



PHP foreach loop can be used with Indexed arrays, Associative arrays and Object public variables.

In foreach loop, the first thing php does is that it creates a copy of the array which is to be iterated over. PHP then iterates over this new copy of the array rather than the original one. This is demonstrated in the below example:

<?php
$numbers = [1,2,3,4,5,6,7,8,9]; # initial values for our array
echo '<pre>', print_r($numbers, true), '</pre>', '<hr />';
foreach($numbers as $index => $number){
    $numbers[$index] = $number + 1; # this is making changes to the origial array
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # showing data from the copied array
}
echo '<hr />', '<pre>', print_r($numbers, true), '</pre>'; # shows the original values (also includes the newly added values).

Besides this, php does allow to use iterated values as a reference to the original array value as well. This is demonstrated below:

<?php
$numbers = [1,2,3,4,5,6,7,8,9];
echo '<pre>', print_r($numbers, true), '</pre>';
foreach($numbers as $index => &$number){
    ++$number; # we are incrementing the original value
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # this is showing the original value
}
echo '<hr />';
echo '<pre>', print_r($numbers, true), '</pre>'; # we are again showing the original value

Note: It does not allow original array indexes to be used as references.

Source: http://dwellupper.io/post/47/understanding-php-foreach-loop-with-examples


5