RecursiveIteratorIteratorjest konkretnym Iteratorwdrażaniu przechodzenie drzewa . Umożliwia programiście przechodzenie przez obiekt kontenera, który implementuje RecursiveIteratorinterfejs. Ogólne zasady, typy, semantyka i wzorce iteratorów można znaleźć w sekcji Iterator w Wikipedii .
W odróżnieniu od IteratorIteratorkonkretnej Iteratorimplementacji przechodzenia przez obiekt w porządku liniowym (i domyślnie akceptującej dowolny rodzaj Traversablew swoim konstruktorze), RecursiveIteratorIteratorumożliwia pętlę po wszystkich węzłach uporządkowanego drzewa obiektów, a jego konstruktor przyjmuje plik RecursiveIterator.
W skrócie: RecursiveIteratorIteratorpozwala na pętlę po drzewie,IteratorIterator pozwala na zapętlenie listy. Pokażę to wkrótce z kilkoma przykładami kodu poniżej.
Technicznie rzecz biorąc, działa to przez wyrwanie się z liniowości przez przejście przez wszystkie elementy potomne węzłów (jeśli takie istnieją). Jest to możliwe, ponieważ z definicji wszystkie dzieci węzła są ponownie RecursiveIterator. Górny poziom Iteratornastępnie wewnętrznie układa różne stosy RecursiveIteratorwedług ich głębokości i utrzymuje wskaźnik na bieżącym aktywnym podrzędnym Iteratorcelu przejścia.
Pozwala to na odwiedzenie wszystkich węzłów drzewa.
Podstawowe zasady są takie same jak w przypadku IteratorIterator: Interfejs określa typ iteracji, a podstawowa klasa iteratora jest implementacją tej semantyki. Porównaj z poniższymi przykładami, w przypadku pętli liniowej foreachzwykle nie myśl o szczegółach implementacji, chyba że musisz zdefiniować nowy Iterator(np. Gdy jakiś konkretny typ sam w sobie nie jestTraversable ).
W przypadku przemierzania rekurencyjnego - chyba że nie używasz predefiniowanej Traversaliteracji przechodzenia, która już ma rekurencyjną iterację przechodzenia - zwykle musisz utworzyć wystąpienie istniejącej RecursiveIteratorIteratoriteracji lub nawet napisać rekurencyjną iterację przechodzenia, która jest Traversabletwoją własną, aby mieć tego typu iterację przechodzenia foreach.
Wskazówka: prawdopodobnie nie zaimplementowałeś jednego ani drugiego własnego, więc może to być coś, co warto zrobić, aby poznać praktyczne różnice, jakie mają. Na końcu odpowiedzi znajdziesz sugestię zrób to sam.
Krótko mówiąc, różnice techniczne:
- Chociaż
IteratorIteratorpobiera dowolne Traversabledla przechodzenia liniowego, RecursiveIteratorIteratorpotrzebuje bardziej szczegółowej RecursiveIteratorpętli po drzewie.
- Tam, gdzie
IteratorIteratoreksponuje swoją główną Iteratorprzelotkę getInnerIerator(), RecursiveIteratorIteratorudostępnia bieżące aktywne sub- Iteratortylko za pomocą tej metody.
- Chociaż
IteratorIteratornie jest świadomy niczego takiego jak rodzic lub dzieci, RecursiveIteratorIteratorwie również, jak zdobyć i przemierzać dzieci.
IteratorIteratornie potrzebuje stosu iteratorów, RecursiveIteratorIteratorma taki stos i zna aktywny pod-iterator.- Gdzie
IteratorIteratorma swoją kolejność ze względu na liniowość i nie ma wyboru, RecursiveIteratorIteratorma wybór dla dalszego przejścia i musi zdecydować dla każdego węzła (decyduje tryb naRecursiveIteratorIterator ).
RecursiveIteratorIteratorma więcej metod niż IteratorIterator.
Podsumowując: RecursiveIteratorto konkretny typ iteracji (pętla po drzewie), który działa na własnych iteratorach, a mianowicie RecursiveIterator. Jest to ta sama podstawowa zasada jak w przypadku IteratorIerator, ale typ iteracji jest inny (kolejność liniowa).
Idealnie byłoby również stworzyć własny zestaw. Jedyną konieczną rzeczą jest to, że Twój iterator implementuje, Traversableco jest możliwe za pośrednictwem Iteratorlub IteratorAggregate. Następnie możesz go używać z foreach. Na przykład jakiś obiekt iteracji rekurencyjnej przechodzenia przez drzewo trójskładnikowe wraz z odpowiednim interfejsem iteracji dla obiektów kontenera.
Przyjrzyjmy się kilku przykładom z życia, które nie są tak abstrakcyjne. Pomiędzy interfejsami, konkretnymi iteratorami, obiektami kontenerów i semantyką iteracji może nie jest to zły pomysł.
Weźmy jako przykład listę katalogów. Weź pod uwagę, że masz na dysku następujące drzewo plików i katalogów:
Podczas gdy iterator z porządkiem liniowym po prostu przechodzi przez folder i pliki najwyższego poziomu (lista pojedynczego katalogu), iterator rekurencyjny przechodzi również przez podfoldery i wyświetla listę wszystkich folderów i plików (lista katalogów z listą jego podkatalogów):
Non-Recursive Recursive
============= =========
[tree] [tree]
├ dirA ├ dirA
└ fileA │ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Możesz łatwo porównać to, z IteratorIteratorktórym nie ma rekursji przy przechodzeniu po drzewie katalogów. I RecursiveIteratorIteratorktóry może przejść do drzewa, jak pokazuje lista Rekurencyjna.
Na początek bardzo prosty przykład z DirectoryIteratorimplementacją, Traversablektóra pozwala foreachna iterację :
$path = 'tree';
$dir = new DirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Przykładowy wynik dla powyższej struktury katalogów to:
[tree]
├ .
├ ..
├ dirA
├ fileA
Jak widać, nie jest to jeszcze używane IteratorIteratorani RecursiveIteratorIterator. Zamiast tego po prostu używa foreachtego, który działa na Traversableinterfejsie.
Ponieważ foreachdomyślnie zna tylko typ iteracji o nazwie porządek liniowy, możemy chcieć jawnie określić typ iteracji. Na pierwszy rzut oka może się to wydawać zbyt rozwlekłe, ale dla celów demonstracyjnych (i aby różnica była RecursiveIteratorIteratorwidoczna później), określmy liniowy typ iteracji, wyraźnie określając IteratorIteratortyp iteracji dla listingu katalogów:
$files = new IteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Ten przykład jest prawie identyczny z pierwszym, różnica polega na tym, że $filesjest to teraz IteratorIteratortyp iteracji dla Traversable $dir:
$files = new IteratorIterator($dir);
Jak zwykle czynność iteracji jest wykonywana przez foreach:
foreach ($files as $file) {
Wynik jest dokładnie taki sam. Więc co się zmieniło? Inny jest obiekt używany w foreach. W pierwszym przykładzie jest to DirectoryIteratoraw drugim przykładzie jest to IteratorIterator. Pokazuje to elastyczność, jaką mają iteratory: możesz je zastąpić innymi, kod wewnątrz foreachpo prostu nadal działa zgodnie z oczekiwaniami.
Zacznijmy od całej listy, łącznie z podkatalogami.
Ponieważ określiliśmy teraz typ iteracji, rozważmy zmianę go na inny typ iteracji.
Wiemy, że musimy teraz przejść całe drzewo, a nie tylko pierwszy poziom. Aby wykonać tę pracę z prostym foreach, potrzebujemy innego typu iteratora:RecursiveIteratorIterator . I to można tylko iterować po obiektach kontenerów, które mają RecursiveIteratorinterfejs .
Interfejs jest umową. Każda klasa implementująca ją może być używana razem z RecursiveIteratorIterator. Przykładem takiej klasy jestRecursiveDirectoryIterator , która jest czymś w rodzaju rekurencyjnej odmiany DirectoryIterator.
Zobaczmy pierwszy przykład kodu przed napisaniem jakiegokolwiek innego zdania ze słowem I:
$dir = new RecursiveDirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Ten trzeci przykład jest prawie identyczny z pierwszym, ale tworzy inne wyniki:
[tree]
├ tree\.
├ tree\..
├ tree\dirA
├ tree\fileA
Okej, nie tak inaczej, nazwa pliku zawiera teraz nazwę ścieżki z przodu, ale reszta również wygląda podobnie.
Jak pokazuje przykład, nawet obiekt katalogu już implementuje RecursiveIteratorinterfejs, ale to nie wystarczy, aby foreachprzejść przez całe drzewo katalogów. Tutaj RecursiveIteratorIteratorzaczyna się akcja. Przykład 4 pokazuje, jak:
$files = new RecursiveIteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Użycie RecursiveIteratorIteratorzamiast tylko poprzedniego $dirobiektu spowoduje foreachprzechodzenie przez wszystkie pliki i katalogi w sposób rekurencyjny. Następnie wyświetla listę wszystkich plików, ponieważ typ iteracji obiektu został określony teraz:
[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
Powinno to już pokazać różnicę między przechodzeniem płaskim i przechodzeniem po drzewie. RecursiveIteratorIteratorJest w stanie przechodzić żadnego drzewiastą strukturę w postaci listy elementów. Ponieważ jest więcej informacji (takich jak poziom, na którym obecnie odbywa się iteracja), można uzyskać dostęp do obiektu iteratora podczas iteracji po nim i na przykład wcinać dane wyjściowe:
echo "[$path]\n";
foreach ($files as $file) {
$indent = str_repeat(' ', $files->getDepth());
echo $indent, " ├ $file\n";
}
Wynik przykładu 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
Oczywiście to nie wygrywa konkursu piękności, ale pokazuje, że w przypadku iteratora rekurencyjnego dostępnych jest więcej informacji niż tylko liniowy porządek klucza i wartości . Nawet foreachmoże wyrazić ten rodzaj liniowości, dostęp do samego iteratora pozwala uzyskać więcej informacji.
Podobnie jak w przypadku metainformacji, istnieją również różne sposoby poruszania się po drzewie, a tym samym porządkowania wyników. To jest tryb programuRecursiveIteratorIterator i można go ustawić za pomocą konstruktora.
W następnym przykładzie RecursiveDirectoryIteratorpolecenie usunie kropki ( .i ..), ponieważ ich nie potrzebujemy. Ale także tryb rekursji zostanie zmieniony, aby najpierw zająć element nadrzędny (podkatalog) (SELF_FIRST ) przed dziećmi (pliki i podkatalogi w podkatalogu):
$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";
}
Dane wyjściowe pokazują teraz poprawnie wymienione pozycje podkatalogów, jeśli porównasz z poprzednim wyjściem, których tam nie było:
[tree]
├ tree\dirA
├ tree\dirA\dirB
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
Dlatego tryb rekurencyjny kontroluje, co i kiedy zwracane jest ramię lub liść w drzewie, dla przykładu katalogu:
LEAVES_ONLY (domyślnie): Tylko lista plików, bez katalogów.SELF_FIRST (powyżej): Lista katalogu, a następnie plików w nim.CHILD_FIRST (bez przykładu): Najpierw wyświetla listę plików w podkatalogu, a następnie w katalogu.
Dane wyjściowe przykładu 5 z dwoma innymi trybami:
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
Porównując to ze standardowym przechodzeniem, wszystkie te rzeczy nie są dostępne. Dlatego iteracja rekurencyjna jest nieco bardziej złożona, gdy trzeba ją owinąć, jednak jest łatwa w użyciu, ponieważ zachowuje się jak iterator, umieszcza się ją w a foreachi gotowe.
Myślę, że to wystarczające przykłady na jedną odpowiedź. Możesz znaleźć pełny kod źródłowy, a także przykład, aby wyświetlić ładnie wyglądające drzewa ascii w tym skrócie: https://gist.github.com/3599532
Zrób to sam: stwórz RecursiveTreeIteratorpracę wiersz po wierszu.
Przykład 5 wykazał, że są dostępne metainformacje o stanie iteratora. Jednak zostało to celowo zademonstrowane w ramach foreachiteracji. W prawdziwym życiu to naturalnie należy doRecursiveIterator .
Lepszym przykładem jest RecursiveTreeIterator, zajmuje się wcięciami, przedrostkami i tak dalej. Zobacz następujący fragment kodu:
$dir = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$lines = new RecursiveTreeIterator($dir);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
RecursiveTreeIteratorPrzeznaczony jest do pracy przy linii linii, wyjście jest dość proste z jednym małym problemem:
[tree]
├ tree\dirA
│ ├ tree\dirA\dirB
│ │ └ tree\dirA\dirB\fileD
│ ├ tree\dirA\fileB
│ └ tree\dirA\fileC
└ tree\fileA
W połączeniu z a RecursiveDirectoryIteratorwyświetla całą nazwę ścieżki, a nie tylko nazwę pliku. Reszta wygląda dobrze. Dzieje się tak, ponieważ nazwy plików są generowane przez SplFileInfo. Zamiast tego powinny być wyświetlane jako nazwa basenowa. Żądane wyjście jest następujące:
[tree]
├ dirA
│ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Utwórz klasę dekoratora, której można używać RecursiveTreeIteratorzamiast RecursiveDirectoryIterator. Powinien zawierać nazwę podstawową prądu SplFileInfozamiast ścieżki. Ostateczny fragment kodu mógłby wtedy wyglądać następująco:
$lines = new RecursiveTreeIterator(
new DiyRecursiveDecorator($dir)
);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Te fragmenty, w tym, $unicodeTreePrefixsą częścią istoty w Dodatku: Zrób to sam: Stwórz RecursiveTreeIteratorpracę wiersz po wierszu. .