RecursiveIteratorIteratorè un attraversamento dell'albero diIterator implementazione concreta . Consente a un programmatore di attraversare un oggetto contenitore che implementa l' interfaccia, vedere Iterator in Wikipedia per i principi generali, i tipi, la semantica e i modelli degli iteratori.RecursiveIterator
A differenza di IteratorIteratorquale sia un Iteratoroggetto di implementazione concreto che attraversa in ordine lineare (e per impostazione predefinita accetta qualsiasi tipo di Traversablenel suo costruttore), il RecursiveIteratorIteratorconsente il ciclo su tutti i nodi in un albero ordinato di oggetti e il suo costruttore prende un file RecursiveIterator.
In breve: RecursiveIteratorIteratorti permette di scorrere un albero, IteratorIteratorti permette di scorrere un elenco. Lo mostro presto con alcuni esempi di codice qui sotto.
Tecnicamente questo funziona rompendo la linearità attraversando tutti i figli di un nodo (se presenti). Questo è possibile perché per definizione tutti i figli di un nodo sono di nuovo a RecursiveIterator. Il livello superiore Iteratorquindi impila internamente i diversi RecursiveIterators in base alla loro profondità e mantiene un puntatore al sub attivo corrente Iteratorper l'attraversamento.
Ciò consente di visitare tutti i nodi di un albero.
I principi di base sono gli stessi di IteratorIterator: Un'interfaccia specifica il tipo di iterazione e la classe iteratore di base è l'implementazione di queste semantiche. Confronta con gli esempi seguenti, per i cicli lineari con foreachte normalmente non pensi molto ai dettagli di implementazione a meno che tu non abbia bisogno di definirne uno nuovo Iterator(ad esempio quando un certo tipo concreto stesso non implementa Traversable).
Per l'attraversamento ricorsivo, a meno che non si utilizzi un predefinito Traversalche ha già un'iterazione trasversale ricorsiva, normalmente è necessario istanziare l' RecursiveIteratorIteratoriterazione esistente o anche scrivere un'iterazione trasversale ricorsiva che è Traversabletua per avere questo tipo di iterazione trasversale foreach.
Suggerimento: probabilmente non hai implementato né l'uno né l'altro, quindi potrebbe essere qualcosa che vale la pena fare per la tua esperienza pratica delle differenze che hanno. Alla fine della risposta trovi un suggerimento fai da te.
Differenze tecniche in breve:
- Sebbene ne
IteratorIteratorprenda qualsiasi Traversableper l'attraversamento lineare, RecursiveIteratorIteratornecessita di un più specifico RecursiveIteratorper eseguire il ciclo su un albero.
- Dove
IteratorIteratorespone la sua Iteratorvia principale getInnerIerator(), RecursiveIteratorIteratorfornisce l'attuale sub-attivo Iteratorsolo tramite quel metodo.
- Sebbene non
IteratorIteratorsia totalmente a conoscenza di nulla come genitore o figli, RecursiveIteratorIteratorsa anche come ottenere e attraversare i bambini.
IteratorIteratornon ha bisogno di uno stack di iteratori, RecursiveIteratorIteratorha un tale stack e conosce il subiteratore attivo.- Where
IteratorIteratorha il suo ordine dovuto alla linearità e nessuna scelta, RecursiveIteratorIteratorha una scelta per un ulteriore attraversamento e deve decidere per ogni nodo (deciso tramite modalità perRecursiveIteratorIterator ).
RecursiveIteratorIteratorha più metodi di IteratorIterator.
Per riassumere: RecursiveIteratorè un tipo concreto di iterazione (loop su un albero) che funziona sui propri iteratori, vale a dire RecursiveIterator. Questo è lo stesso principio di base di IteratorIerator, ma il tipo di iterazione è diverso (ordine lineare).
Idealmente puoi anche creare il tuo set. L'unica cosa necessaria è che il tuo iteratore implementa il Traversableche è possibile tramite Iteratoro IteratorAggregate. Quindi puoi usarlo con foreach. Ad esempio una sorta di oggetto di iterazione ricorsiva di attraversamento dell'albero ternario insieme all'interfaccia di iterazione corrispondente per gli oggetti contenitore.
Rivediamo con alcuni esempi di vita reale che non sono così astratti. Tra interfacce, iteratori concreti, oggetti contenitore e semantica di iterazione questa forse non è una cattiva idea.
Prendi un elenco di directory come esempio. Considera di avere il seguente albero di file e directory su disco:
Mentre un iteratore con ordine lineare attraversa semplicemente la cartella ei file di primo livello (un singolo elenco di directory), l'iteratore ricorsivo attraversa anche le sottocartelle ed elenca tutte le cartelle ei file (un elenco di directory con elenchi delle sue sottodirectory):
Non-Recursive Recursive
============= =========
[tree] [tree]
├ dirA ├ dirA
└ fileA │ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Puoi facilmente confrontare questo con il IteratorIteratorquale non fa ricorsione per attraversare l'albero delle directory. E il RecursiveIteratorIteratorquale può attraversare l'albero come mostra l'elenco ricorsivo.
All'inizio un esempio molto semplice con un DirectoryIteratorthat implements Traversableche permette foreachdi iterare su di esso:
$path = 'tree';
$dir = new DirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
L'output esemplare per la struttura della directory sopra è quindi:
[tree]
├ .
├ ..
├ dirA
├ fileA
Come vedi questo non sta ancora usando IteratorIteratoro RecursiveIteratorIterator. Invece è solo usando foreachche opera Traversablesull'interfaccia.
Poiché foreachper impostazione predefinita conosce solo il tipo di iterazione denominato ordine lineare, potremmo voler specificare esplicitamente il tipo di iterazione. A prima vista potrebbe sembrare troppo prolisso, ma a scopo dimostrativo (e per fare la differenza RecursiveIteratorIteratorpiù visibile in seguito), specifichiamo il tipo lineare di iterazione specificando esplicitamente il IteratorIteratortipo di iterazione per l'elenco delle directory:
$files = new IteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Questo esempio è quasi identico al primo, la differenza è che $filesora è un IteratorIteratortipo di iterazione per Traversable $dir:
$files = new IteratorIterator($dir);
Come al solito, l'atto di iterazione viene eseguito da foreach:
foreach ($files as $file) {
L'output è esattamente lo stesso. Allora cosa c'è di diverso? Diverso è l'oggetto utilizzato all'interno di foreach. Nel primo esempio è un DirectoryIteratornel secondo esempio è il IteratorIterator. Questo mostra la flessibilità che hanno gli iteratori: puoi sostituirli tra loro, il codice all'interno foreachcontinua a funzionare come previsto.
Iniziamo per ottenere l'intero elenco, comprese le sottodirectory.
Poiché ora abbiamo specificato il tipo di iterazione, consideriamo di cambiarlo in un altro tipo di iterazione.
Sappiamo che ora dobbiamo attraversare l'intero albero, non solo il primo livello. Per avere che il lavoro con un semplice foreachabbiamo bisogno di un diverso tipo di iteratore: RecursiveIteratorIterator. E quello può solo iterare su oggetti contenitore che hanno l' RecursiveIteratorinterfaccia .
L'interfaccia è un contratto. Qualsiasi classe che lo implementa può essere utilizzata insieme a RecursiveIteratorIterator. Un esempio di una tale classe è il RecursiveDirectoryIterator, che è qualcosa come la variante ricorsiva di DirectoryIterator.
Vediamo un primo esempio di codice prima di scrivere qualsiasi altra frase con la parola I:
$dir = new RecursiveDirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Questo terzo esempio è quasi identico al primo, tuttavia crea un output diverso:
[tree]
├ tree\.
├ tree\..
├ tree\dirA
├ tree\fileA
Ok, non è così diverso, il nome del file ora contiene il percorso davanti, ma anche il resto sembra simile.
Come mostra l'esempio, anche l'oggetto directory implementa già l' RecursiveIteratorinterfaccia, questo non è ancora sufficiente per far foreachattraversare l'intero albero delle directory. È qui che RecursiveIteratorIteratorentra in azione. L'esempio 4 mostra come:
$files = new RecursiveIteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Usare il RecursiveIteratorIteratorinvece del solo $diroggetto precedente farà foreachattraversare tutti i file e le directory in modo ricorsivo. Questo quindi elenca tutti i file, poiché il tipo di iterazione dell'oggetto è stato specificato ora:
[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
Questo dovrebbe già dimostrare la differenza tra attraversamento piatto e albero. È in RecursiveIteratorIteratorgrado di attraversare qualsiasi struttura ad albero come un elenco di elementi. Poiché ci sono più informazioni (come il livello in cui avviene attualmente l'iterazione), è possibile accedere all'oggetto iteratore mentre si itera su di esso e ad esempio indentare l'output:
echo "[$path]\n";
foreach ($files as $file) {
$indent = str_repeat(' ', $files->getDepth());
echo $indent, " ├ $file\n";
}
E output dell'Esempio 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
Sicuramente questo non vince un concorso di bellezza, ma mostra che con l'iteratore ricorsivo sono disponibili più informazioni oltre all'ordine lineare di chiave e valore . Anche foreachsolo può esprimere questo tipo di linearità, l'accesso all'iteratore stesso permette di ottenere maggiori informazioni.
Simile alle meta-informazioni ci sono anche diversi modi possibili per attraversare l'albero e quindi ordinare l'output. Questa è la modalità diRecursiveIteratorIterator e può essere impostata con il costruttore.
Il prossimo esempio dirà RecursiveDirectoryIteratora di rimuovere le voci di punto ( .e ..) poiché non ne abbiamo bisogno. Ma anche la modalità di ricorsione verrà modificata per prendere l'elemento genitore (la sottodirectory) prima ( SELF_FIRST) prima dei figli (i file e le sottodirectory nella sottodirectory):
$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";
}
L'output ora mostra le voci della sottodirectory correttamente elencate, se si confronta con l'output precedente quelle non c'erano:
[tree]
├ tree\dirA
├ tree\dirA\dirB
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
La modalità di ricorsione controlla quindi cosa e quando viene restituito un brach o una foglia nell'albero, per l'esempio di directory:
LEAVES_ONLY (impostazione predefinita): elenca solo i file, nessuna directory.SELF_FIRST (sopra): elenca la directory e poi i file al suo interno.CHILD_FIRST (senza esempio): elenca prima i file nella sottodirectory, quindi la directory.
Risultato dell'esempio 5 con le altre due modalità:
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
Quando lo confronti con l'attraversamento standard, tutte queste cose non sono disponibili. L'iterazione ricorsiva quindi è un po 'più complessa quando è necessario avvolgere la testa attorno ad essa, tuttavia è facile da usare perché si comporta proprio come un iteratore, lo metti in un foreache fatto.
Penso che questi siano esempi sufficienti per una risposta. Puoi trovare il codice sorgente completo e un esempio per visualizzare alberi ascii di bell'aspetto in questo riassunto: https://gist.github.com/3599532
Fai da te: crea il RecursiveTreeIteratorlavoro riga per riga.
L'esempio 5 ha dimostrato che sono disponibili meta-informazioni sullo stato dell'iteratore. Tuttavia, questo è stato volutamente dimostrata all'interno della foreachiterazione. Nella vita reale questo appartiene naturalmente al RecursiveIterator.
Un esempio migliore è il RecursiveTreeIterator, si occupa del rientro, del prefisso e così via. Vedere il seguente frammento di codice:
$dir = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$lines = new RecursiveTreeIterator($dir);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Il RecursiveTreeIteratorè destinato alla linea di lavoro per riga, l'uscita è abbastanza semplice con un piccolo problema:
[tree]
├ tree\dirA
│ ├ tree\dirA\dirB
│ │ └ tree\dirA\dirB\fileD
│ ├ tree\dirA\fileB
│ └ tree\dirA\fileC
└ tree\fileA
Quando viene utilizzato in combinazione con a RecursiveDirectoryIterator, visualizza l'intero percorso e non solo il nome del file. Il resto sembra buono. Questo perché i nomi dei file vengono generati da SplFileInfo. Quelli dovrebbero essere visualizzati come nome di base invece. L'output desiderato è il seguente:
/// Solved ///
[tree]
├ dirA
│ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Crea una classe decoratore che può essere utilizzata al RecursiveTreeIteratorposto di RecursiveDirectoryIterator. Dovrebbe fornire il nome di base della corrente SplFileInfoinvece del percorso. Il frammento di codice finale potrebbe quindi essere simile a:
$lines = new RecursiveTreeIterator(
new DiyRecursiveDecorator($dir)
);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Questi frammenti, inclusi, $unicodeTreePrefixfanno parte dell'essenza nell'Appendice: Fai da te: crea il RecursiveTreeIteratorlavoro linea per linea. .