RecursiveIteratorIterator- это конкретная Iteratorреализация обхода дерева . Он позволяет программисту перемещаться по объекту-контейнеру, реализующему RecursiveIteratorинтерфейс. Общие принципы, типы, семантика и шаблоны итераторов см. В разделе « Итератор» в Википедии .
В отличие от IteratorIteratorконкретного Iteratorреализуемого обхода объекта в линейном порядке (и по умолчанию принимающего любой тип Traversableв своем конструкторе), RecursiveIteratorIteratorпозволяет выполнять цикл по всем узлам в упорядоченном дереве объектов, а его конструктор принимает RecursiveIterator.
Вкратце: RecursiveIteratorIteratorпозволяет перебирать дерево, IteratorIteratorпозволяет перебирать список. Я покажу это на некоторых примерах кода ниже.
Технически это работает путем выхода из линейности путем обхода всех дочерних узлов (если таковые имеются). Это возможно, потому что по определению все дочерние элементы узла снова являются RecursiveIterator. Затем верхний уровень Iteratorвнутренне складывает различные RecursiveIterators по их глубине и сохраняет указатель на текущий активный подпрограмм Iteratorдля обхода.
Это позволяет посещать все узлы дерева.
Основные принципы такие же, как и в случае IteratorIterator: интерфейс определяет тип итерации, а базовый класс итератора является реализацией этой семантики. Сравните с примерами ниже, для линейного цикла foreachвы обычно не задумываетесь о деталях реализации, если вам не нужно определять новый Iterator(например, когда какой-то конкретный тип сам по себе не реализуется Traversable).
Для рекурсивного обхода - если вы не используете предопределенный, Traversalкоторый уже имеет рекурсивную итерацию обхода - вам обычно нужно создать экземпляр существующей RecursiveIteratorIteratorитерации или даже написать рекурсивную итерацию обхода, которая является Traversableвашей собственной, чтобы иметь этот тип итерации обхода foreach.
Совет: вы, вероятно, не реализовали ни то, ни другое самостоятельно, так что это может быть чем-то стоящим для вашего практического опыта различий между ними. В конце ответа вы найдете предложение «Сделай сам».
Кратко о технических отличиях:
- Хотя для линейного обхода
IteratorIteratorтребуется любое Traversable, RecursiveIteratorIteratorтребуется более конкретное RecursiveIteratorдля циклического обхода дерева.
- Где
IteratorIteratorпредоставляет свое основное переходное Iteratorотверстие getInnerIerator(), RecursiveIteratorIteratorпредоставляет текущий активный вспомогательный Iteratorтолько через этот метод.
- Хотя
IteratorIteratorсовершенно ничего не известно о родителях или детях, но также RecursiveIteratorIteratorзнает, как получить и пересечь детей.
IteratorIteratorне нуждается в стеке итераторов, RecursiveIteratorIteratorимеет такой стек и знает активный суб-итератор.- Где
IteratorIteratorимеет свой порядок из-за линейности и отсутствия выбора, RecursiveIteratorIteratorимеет выбор для дальнейшего обхода и должен решать для каждого узла (определяется с помощью режима perRecursiveIteratorIterator ).
RecursiveIteratorIteratorимеет больше методов, чем IteratorIterator.
Подводя итог: RecursiveIteratorэто конкретный тип итерации (цикл по дереву), который работает на собственных итераторах, а именно RecursiveIterator. Это тот же основной принцип, что и с IteratorIerator, но тип итерации другой (линейный порядок).
В идеале вы также можете создать свой собственный набор. Единственное, что необходимо, это чтобы ваш итератор реализовал то, Traversableчто возможно через Iteratorили IteratorAggregate. Тогда вы можете использовать его с foreach. Например, некоторый вид рекурсивного объекта итерации обхода троичного дерева вместе с соответствующим интерфейсом итерации для объекта (ов) контейнера.
Давайте рассмотрим несколько примеров из реальной жизни, которые не являются настолько абстрактными. Между интерфейсами, конкретными итераторами, контейнерными объектами и семантикой итераций это, возможно, не такая уж плохая идея.
В качестве примера возьмем список каталогов. Предположим, у вас есть следующее дерево файлов и каталогов на диске:
В то время как итератор с линейным порядком просто перемещается по папке и файлам верхнего уровня (один листинг каталогов), рекурсивный итератор также проходит по вложенным папкам и перечисляет все папки и файлы (список каталогов со списками его подкаталогов):
Non-Recursive Recursive
============= =========
[tree] [tree]
├ dirA ├ dirA
└ fileA │ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Вы можете легко сравнить это с тем, IteratorIteratorчто не выполняет рекурсию для обхода дерева каталогов. И RecursiveIteratorIteratorкоторый может перемещаться в дерево, как показано в рекурсивном списке.
Сначала очень простой пример с микросхемой DirectoryIterator, реализующий Traversableкоторый позволяет foreachдля итерации над ним:
$path = 'tree';
$dir = new DirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Примерный результат для структуры каталогов выше:
[tree]
├ .
├ ..
├ dirA
├ fileA
Как видите, здесь еще не используется IteratorIteratorили RecursiveIteratorIterator. Вместо этого он просто использует foreachто, что работает с Traversableинтерфейсом.
Поскольку foreachпо умолчанию известен только тип итерации с именем linear order, мы могли бы явно указать тип итерации. На первый взгляд это может показаться слишком многословным, но для демонстрационных целей (и чтобы разница была RecursiveIteratorIteratorболее заметной позже), давайте укажем линейный тип итерации, явно указав IteratorIteratorтип итерации для списка каталогов:
$files = new IteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Этот пример почти идентичен первому, разница в том, что $filesтеперь это IteratorIteratorтип итерации для Traversable $dir:
$files = new IteratorIterator($dir);
Как обычно, итерация выполняется foreach:
foreach ($files as $file) {
Результат точно такой же. Так что же другое? Другой объект, используемый в foreach. В первом примере это. Во DirectoryIteratorвтором примере это IteratorIterator. Это показывает гибкость итераторов: вы можете заменять их друг на друга, код внутри foreachпросто продолжает работать должным образом.
Приступим к получению всего списка, включая подкаталоги.
Поскольку мы теперь указали тип итерации, давайте рассмотрим возможность изменения его на другой тип итерации.
Мы знаем, что теперь нам нужно пройти все дерево, а не только первый уровень. Для того, чтобы иметь эту работу с простым foreachнам нужен другой тип итератора: RecursiveIteratorIterator. И это можно делать только по объектам контейнера, у которых есть RecursiveIteratorинтерфейс .
Интерфейс - это контракт. Любой класс, реализующий его, можно использовать вместе с RecursiveIteratorIterator. Примером такого класса является RecursiveDirectoryIterator, что-то вроде рекурсивного варианта DirectoryIterator.
Давайте посмотрим на первый пример кода, прежде чем писать любое другое предложение с I-словом:
$dir = new RecursiveDirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Этот третий пример почти идентичен первому, однако он создает другой результат:
[tree]
├ tree\.
├ tree\..
├ tree\dirA
├ tree\fileA
Хорошо, не так уж и много, имя файла теперь содержит путь впереди, но остальное тоже похоже.
Как показывает пример, даже объект каталога уже реализует RecursiveIteratorинтерфейс, этого еще недостаточно для foreachобхода всего дерева каталогов. Здесь RecursiveIteratorIteratorвступает в действие. Пример 4 показывает, как:
$files = new RecursiveIteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Использование RecursiveIteratorIteratorвместо предыдущего $dirобъекта приведет foreachк рекурсивному обходу всех файлов и каталогов. Затем в нем перечислены все файлы, так как тип итерации объекта уже указан:
[tree]
├ tree\.
├ tree\..
├ tree\dirA\.
├ tree\dirA\..
├ tree\dirA\dirB\.
├ tree\dirA\dirB\..
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
Это уже должно продемонстрировать разницу между обходом по плоскости и по дереву. RecursiveIteratorIteratorМожет пройти любую древовидную структуру в виде списка элементов. Поскольку существует больше информации (например, уровень, на котором итерация происходит в настоящее время), можно получить доступ к объекту итератора во время итерации по нему и, например, сделать отступ для вывода:
echo "[$path]\n";
foreach ($files as $file) {
$indent = str_repeat(' ', $files->getDepth());
echo $indent, " ├ $file\n";
}
И вывод примера 5 :
[tree]
├ tree\.
├ tree\..
├ tree\dirA\.
├ tree\dirA\..
├ tree\dirA\dirB\.
├ tree\dirA\dirB\..
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
Конечно, это не победа в конкурсе красоты, но показывает, что с рекурсивным итератором доступно больше информации, чем просто линейный порядок ключа и значения . Даже foreachможет выражать только такую линейность, доступ к самому итератору позволяет получить больше информации.
Подобно метаинформации, существуют также различные способы обхода дерева и, следовательно, упорядочивания вывода. Это режим изRecursiveIteratorIterator и он может быть установлен с помощью конструктора.
В следующем примере будет сказано RecursiveDirectoryIteratorудалить записи с точками ( .и ..), поскольку они нам не нужны. Но также будет изменен режим рекурсии, чтобы родительский элемент (подкаталог) сначала ( SELF_FIRST) принимал дочерние элементы ( файлы и подкаталоги в подкаталоге):
$dir = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$files = new RecursiveIteratorIterator($dir, RecursiveIteratorIterator::SELF_FIRST);
echo "[$path]\n";
foreach ($files as $file) {
$indent = str_repeat(' ', $files->getDepth());
echo $indent, " ├ $file\n";
}
В выводе теперь правильно отображаются записи подкаталогов, если вы сравните их с предыдущим выводом, которых там не было:
[tree]
├ tree\dirA
├ tree\dirA\dirB
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
Таким образом, режим рекурсии управляет тем, что и когда возвращается ветвь или лист в дереве, для примера каталога:
LEAVES_ONLY (по умолчанию): только список файлов, без каталогов.SELF_FIRST (вверху): Список каталога, а затем файлы в нем.CHILD_FIRST (без примера): сначала перечислите файлы в подкаталоге, затем в каталоге.
Результат примера 5 с двумя другими режимами:
LEAVES_ONLY CHILD_FIRST
[tree] [tree]
├ tree\dirA\dirB\fileD ├ tree\dirA\dirB\fileD
├ tree\dirA\fileB ├ tree\dirA\dirB
├ tree\dirA\fileC ├ tree\dirA\fileB
├ tree\fileA ├ tree\dirA\fileC
├ tree\dirA
├ tree\fileA
Если сравнить это со стандартным обходом, все это недоступно. Таким образом, рекурсивная итерация немного сложнее, когда вам нужно обдумать ее, однако ее легко использовать, потому что она ведет себя так же, как итератор, вы помещаете ее в a foreachи готово.
Думаю, этого достаточно для одного ответа. Вы можете найти полный исходный код, а также пример отображения красивых ascii-деревьев в этой сущности: https://gist.github.com/3599532
Сделай сам: сделай RecursiveTreeIteratorработу строка за строкой.
Пример 5 продемонстрировал наличие метаинформации о состоянии итератора. Однако в рамках foreachитерации это было целенаправленно продемонстрировано . В реальной жизни это, естественно, принадлежит внутри RecursiveIterator.
Лучшим примером является то RecursiveTreeIterator, что он заботится об отступах, префиксе и так далее. См. Следующий фрагмент кода:
$dir = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$lines = new RecursiveTreeIterator($dir);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Он RecursiveTreeIteratorпредназначен для работы построчно, вывод довольно прост с одной небольшой проблемой:
[tree]
├ tree\dirA
│ ├ tree\dirA\dirB
│ │ └ tree\dirA\dirB\fileD
│ ├ tree\dirA\fileB
│ └ tree\dirA\fileC
└ tree\fileA
При использовании в сочетании с a RecursiveDirectoryIteratorон отображает полный путь, а не только имя файла. В остальном выглядит неплохо. Это потому, что имена файлов генерируются SplFileInfo. Вместо этого они должны отображаться как базовое имя. Желаемый результат следующий:
[tree]
├ dirA
│ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Создайте класс декоратора, который можно использовать RecursiveTreeIteratorвместо RecursiveDirectoryIterator. Он должен предоставлять базовое имя текущего SplFileInfoвместо имени пути. Окончательный фрагмент кода мог бы выглядеть так:
$lines = new RecursiveTreeIterator(
new DiyRecursiveDecorator($dir)
);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Эти фрагменты, в том числе, $unicodeTreePrefixявляются частью сути Приложения «Сделай сам: сделай RecursiveTreeIteratorработу линия за строкой». .