Comment RecursiveIteratorIterator travail en PHP?

RecursiveIteratorIterator est un béton Iterator la mise en œuvre de l'arbre transversal. Il permet au programmeur de parcourir un conteneur d'objet qui implémente l' RecursiveIterator interface, voir Itérateur dans Wikipedia pour les principes généraux, les types, de la sémantique et des modèles de itérateurs.

Dans la différence de IteratorIterator qui est un béton Iterator la mise en œuvre de l'objet de traversée de l'ordre linéaire en (et par défaut, en acceptant tout type de Traversable dans son constructeur), le RecursiveIteratorIterator permet de boucler sur tous les nœuds dans un commandé arbre d'objets et de son constructeur prend un RecursiveIterator.

En bref: RecursiveIteratorIterator permet de vous faire une boucle sur un arbre, IteratorIterator permet de vous faire une boucle sur une liste. Je montre que, avec des exemples de code ci-dessous bientôt.

Techniquement cela fonctionne par rupture de la linéarité en parcourant tout les nœuds enfants (le cas échéant). Cela est possible parce que, par définition, tous les enfants d'un nœud sont encore une RecursiveIterator. Le toplevel Iterator puis interne des piles différentes RecursiveIterators par leur profondeur et conserve un pointeur vers le courant actif sous Iterator pour la traversée.

Cela permet de visiter tous les nœuds d'un arbre.

Les principes sous-jacents sont les mêmes qu'avec IteratorIterator: Une interface spécifie le type d'itération de base et la classe iterator est la mise en œuvre de ces sémantique. Comparer avec les exemples ci-dessous, pour linéaire en boucle avec foreach vous normalement ne pense pas que sur les détails de mise en œuvre, sauf si vous avez besoin de définir un nouveau Iterator (par exemple, lorsque certains type de béton lui-même ne pas mettre en œuvre Traversable).

Récursive de la traversée - à moins que vous n'utilisez pas un pré-définis Traversal qui a déjà récursive de la traversée à l'itération - vous normalement besoin pour instancier l'existant RecursiveIteratorIterator itération ou même d'écrire un appel récursif à la traversée de l'itération est un Traversable votre propre à ce type de traversée de l'itération avec foreach.

Astuce: Vous n'avez probablement pas mettre en œuvre l'un ni l'autre de votre propre, donc cela pourrait être quelque chose d'intéressant à faire pour votre expérience pratique de leurs différences. Vous trouverez un magasin de BRICOLAGE suggestion à la fin de la réponse.

Différences techniques en bref:

• Tout IteratorIterator prend tout Traversable linéaire transversal, RecursiveIteratorIterator besoins plus spécifiques, RecursiveIterator faire une boucle sur un arbre.
• Où IteratorIterator expose ses principales Iterator via getInnerIerator(), RecursiveIteratorIterator fournit le courant actif sous-Iterator uniquement via cette méthode.
• Tout IteratorIterator est totalement pas au courant de quoi que ce soit comme parent ou enfants, RecursiveIteratorIterator sait comment l'obtenir et traverse les enfants.
• IteratorIterator n'a pas besoin d'une pile de itérateurs, RecursiveIteratorIterator a une pile et sait l'actif sous-itérateur.
• Où IteratorIterator a son ordre en raison de la linéarité et la pas le choix, RecursiveIteratorIterator a un choix pour plus transversal et doit décider, pour chaque nœud (décidé par mode par RecursiveIteratorIterator).
• RecursiveIteratorIterator a plus de méthodes IteratorIterator.

Pour résumer: RecursiveIterator est un type concret de l'itération (en boucle sur un arbre) qui travaille sur son propre itérateurs, à savoir RecursiveIterator. C'est le même principe qu'avec IteratorIerator, mais le type d'itération est différent (ordre linéaire).

Idéalement, vous pouvez créer votre propre jeu, trop. La seule chose nécessaire est que votre itérateur implémente Traversable qui est possible via Iterator ou IteratorAggregate. Ensuite, vous pouvez l'utiliser avec foreach. Par exemple une sorte de ternaire de l'arbre transversal récursive itération de l'objet avec la fonction d'itération de l'interface de l'objet conteneur(s).

---

Passons en revue avec quelques exemples de la vie réelle qui ne sont pas abstraites. Entre les interfaces, béton les itérateurs, d'un conteneur d'objets d'itération et de la sémantique, ce n'est peut être pas une mauvais idée.

Prendre un listing de répertoire comme un exemple. Considérez que vous avez obtenu le fichier suivant et de l'arborescence des répertoires sur le disque:

Tandis qu'un itérateur, ordre linéaire viens de parcourir au cours de la racine de dossiers et de fichiers (une seule liste de répertoire), le récursive itérateur parcourt les sous-dossiers ainsi et la liste de tous les dossiers et fichiers (une liste de répertoire avec des annonces de ses sous-répertoires):

Non-Recursive        Recursive
=============        =========

   [tree]            [tree]
    ├ dirA            ├ dirA
    └ fileA           │ ├ dirB
                      │ │ └ fileD
                      │ ├ fileB
                      │ └ fileC
                      └ fileA

Vous pouvez facilement les comparer avec IteratorIterator qui n'a pas de récursivité pour parcourir l'arborescence des répertoires. Et le RecursiveIteratorIterator qui peut parcourir dans l'arbre que les Récursive liste indique.

Au premier abord un exemple très simple avec un DirectoryIterator qui implémente Traversable qui permet foreach à itérer dessus:

$path = 'tree';
$dir  = new DirectoryIterator($path);

echo "[$path]\n";
foreach ($dir as $file) {
    echo " ├ $file\n";
}

L'exemplaire de sortie pour la structure de répertoire ci-dessus est alors:

[tree]
 ├ .
 ├ ..
 ├ dirA
 ├ fileA

Comme vous le voyez ce n'est pas encore à l'aide de IteratorIterator ou RecursiveIteratorIterator. Au lieu de cela il tout simplement à l'aide de foreach qui fonctionne sur le Traversable interface.

Comme foreach par défaut ne connaît que le type d'itération nommée ordre linéaire, on peut spécifier le type d'itération explicitement. À première vue, il peut sembler trop verbeux, mais pour les besoins de la démonstration (et de faire la différence avec RecursiveIteratorIterator plus visible plus tard), permet de spécifier le type linéaire de l'itération de spécifier explicitement l' IteratorIterator type d'itération pour l'inscription à l'annuaire:

$files = new IteratorIterator($dir);

echo "[$path]\n";
foreach ($files as $file) {
    echo " ├ $file\n";
}

Cet exemple est près de identique à la première, la différence est que $files est maintenant un IteratorIterator type d'itération pour Traversable $dir:

$files = new IteratorIterator($dir);

Comme d'habitude, la loi de l'itération est effectuée par le foreach:

foreach ($files as $file) {

La sortie est exactement le même. Donc ce qui est différent? Différente est l'objet utilisé dans le foreach. Dans le premier exemple, c'est un DirectoryIterator dans le deuxième exemple, c'est le IteratorIterator. Cela montre la flexibilité des itérateurs ont: Vous pouvez remplacer les uns avec les autres, le code à l'intérieur foreach il suffit de continuer à fonctionner comme prévu.

Permet de commencer à obtenir toute la liste, y compris les sous-répertoires.

Maintenant que nous avons spécifié le type de l'itération, nous allons envisager de le changer pour un autre type d'itération.

Nous savons que nous avons besoin de parcourir toute l'arborescence maintenant, non seulement le premier niveau. Pour le fonctionnement avec un simple foreach nous avons besoin d'un autre type d'itérateur: RecursiveIteratorIterator. Et que l'on ne peut itérer sur conteneur des objets qui ont le RecursiveIterator de l'interface.

L'interface est un contrat. Toute classe implémentant il peut être utilisé conjointement avec le RecursiveIteratorIterator. Un exemple d'une telle classe est la RecursiveDirectoryIterator, qui est quelque chose comme la variante récursive de DirectoryIterator.

Permet de voir un premier exemple de code avant d'écrire une phrase avec le mot:

$dir  = new RecursiveDirectoryIterator($path);

echo "[$path]\n";
foreach ($dir as $file) {
    echo " ├ $file\n";
}

Ce troisième exemple est près de identique à la première, mais elle crée une certaine différente de sortie:

[tree]
 ├ tree\.
 ├ tree\..
 ├ tree\dirA
 ├ tree\fileA

Ok, pas si différent, le nom de fichier contient le chemin d'accès à l'avant, mais le reste ressemble ainsi.

Comme le montre l'exemple, même l'objet d'annuaire déjà imlements la RecursiveIterator de l'interface, ce n'est pas encore assez pour faire foreach traverse l'ensemble de l'arborescence du répertoire. C'est là que le RecursiveIteratorIterator entre en action. Exemple 4 montre comment:

$files = new RecursiveIteratorIterator($dir);

echo "[$path]\n";
foreach ($files as $file) {
    echo " ├ $file\n";
}

À l'aide de la RecursiveIteratorIterator au lieu de simplement la précédente $dir objet de faire foreach de parcourir plus de tous les fichiers et répertoires de manière récursive. Cette énumère ensuite tous les fichiers, comme le type de l'objet d'itération a été spécifié maintenant:

[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

Ce qui devrait déjà démontrer la différence entre les plats et l'arbre transversal. Le RecursiveIteratorIterator est capable de traverser toute la structure en arbre comme une liste d'éléments. Parce qu'il n'y est plus de l'information (comme le niveau de l'itération prend actuellement en place), il est possible d'accéder à l'itérateur de l'objet lors de l'itération sur elle, et par exemple en retrait de la sortie:

echo "[$path]\n";
foreach ($files as $file) {
    $indent = str_repeat('   ', $files->getDepth());
    echo $indent, " ├ $file\n";
}

Et de sortie de Exemple 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

Sûr que ce n'est pas de gagner un concours de beauté, mais il montre que, avec le récursive itérateur, il n'y a plus d'informations disponibles que juste l'ordre linéaire de clé et valeur. Même foreach ne peut qu'exprimer ce genre de linéarité, l'accès à l'itérateur en lui-même permet d'obtenir plus d'informations.

Similaire à la méta-information, il existe également différentes manières sur la façon de parcourir l'arbre et, par conséquent, de l'ordre de la sortie. C'est le Mode de la RecursiveIteratorIterator et il peut être réglé avec le constructeur.

L'exemple suivant, on va dire le RecursiveDirectoryIterator pour supprimer le point d'entrées (. et ..) que nous n'avons pas besoin d'eux. Mais aussi la récursivité mode sera modifiée afin de prendre le parent de l'élément (le sous-répertoire) premier ( SELF_FIRST ), avant que les enfants (les fichiers et les sous-sous-dossiers dans le sous-répertoire):

$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";
}

La sortie montre maintenant le sous-répertoire entrées correctement indiqué, si vous comparez avec le résultat précédent ceux qui n'étaient pas là:

[tree]
 ├ tree\dirA
    ├ tree\dirA\dirB
       ├ tree\dirA\dirB\fileD
    ├ tree\dirA\fileB
    ├ tree\dirA\fileC
 ├ tree\fileA

La récursivité mode de contrôle donc quoi et quand un brach ou feuille de l'arbre est renvoyé, pour le répertoire exemple:

• LEAVES_ONLY (par défaut): Seuls les fichiers de la liste, pas de répertoires.
• SELF_FIRST (ci-dessus): Liste de répertoire et les fichiers là.
• CHILD_FIRST (w/o exemple): Liste les fichiers dans le répertoire en premier, puis le répertoire.

Sortie de Exemple 5 avec les deux autres modes:

  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

Lorsque vous comparez cela avec la traversée standard, toutes ces choses ne sont pas disponibles. Récursive itération est donc un peu plus complexe quand vous en avez besoin pour envelopper votre tête autour de lui, cependant il est facile à utiliser car il se comporte comme un itérateur, vous la mettez dans un foreach et fait.

Je pense qu'ils sont assez d'exemples pour une réponse. Vous trouverez l'intégralité du code source, ainsi qu'un exemple d'afficher de jolies ascii-arbres dans ce gist: https://gist.github.com/3599532

Le faire Vous-même: Faire la RecursiveTreeIterator Travailler ligne par Ligne.

Exemple 5 démontré qu'il existe des méta-informations sur l'itérateur de l'état disponible. Toutefois, cela a été délibérément démontré dans la foreach itération. Dans la vraie vie, naturellement, cela appartient à l'intérieur de la RecursiveIterator.

Meilleur exemple en est la RecursiveTreeIterator, il prend soin de l'indentation, la préfixation et ainsi de suite. Voir le fragment de code suivant:

$dir   = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$lines = new RecursiveTreeIterator($dir);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));

La RecursiveTreeIterator est destiné à travailler ligne par ligne, la sortie est assez simple, avec un petit problème:

[tree]
 ├ tree\dirA
 │ ├ tree\dirA\dirB
 │ │ └ tree\dirA\dirB\fileD
 │ ├ tree\dirA\fileB
 │ └ tree\dirA\fileC
 └ tree\fileA

Lorsqu'utilisé en combinaison avec un RecursiveDirectoryIterator il affiche tout le chemin et de ne pas simplement le nom de fichier. Le reste semble bon. C'est parce que les noms de fichiers sont générés par SplFileInfo. Celles-ci doivent être affichés sous le nom de base à la place. Le résultat souhaité est le suivant:

///Solved ///

[tree]
 ├ dirA
 │ ├ dirB
 │ │ └ fileD
 │ ├ fileB
 │ └ fileC
 └ fileA

Créer un décorateur classe qui peut être utilisée avec RecursiveTreeIterator au lieu de la RecursiveDirectoryIterator. Il doit fournir le nom de base de l'actuel SplFileInfo au lieu du chemin. Le dernier fragment de code pourrait alors ressembler à ceci:

$lines = new RecursiveTreeIterator(
    new DiyRecursiveDecorator($dir)
);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));

Ces fragments dont $unicodeTreePrefix font partie de l'essentiel dans Annexe: Do It Yourself: Faites le RecursiveTreeIterator Travailler ligne par Ligne..

RecursiveDirectoryIterator il affiche tout le chemin et de ne pas simplement le nom de fichier. Le reste semble bon. C'est parce que les noms de fichiers sont générés par SplFileInfo. Celles-ci doivent être affichés sous le nom de base à la place. Le résultat souhaité est le suivant:

$path =__DIR__;
$dir = new RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS);
$files = new RecursiveIteratorIterator($dir,RecursiveIteratorIterator::SELF_FIRST);
while ($files->valid()) {
    $file = $files->current();
    $filename = $file->getFilename();
    $deep = $files->getDepth();
    $indent = str_repeat('│ ', $deep);
    $files->next();
    $valid = $files->valid();
    if ($valid and ($files->getDepth() - 1 == $deep or $files->getDepth() == $deep)) {
        echo $indent, "├ $filename\n";
    } else {
        echo $indent, "└ $filename\n";
    }
}

de sortie:

tree
 ├ dirA
 │ ├ dirB
 │ │ └ fileD
 │ ├ fileB
 │ └ fileC
 └ fileA