RecursiveIteratorIteratoré uma travessia de árvore deIterator implementação concreta . Ele permite que um programador atravesse um objeto contêiner que implementa a interface, consulte Iterator na Wikipedia para os princípios gerais, tipos, semânticas e padrões de iteradores.RecursiveIterator
Diferentemente de IteratorIteratorqual é um Iteratorobjeto de implementação concreto atravessando em ordem linear (e por padrão aceitando qualquer tipo de Traversableem seu construtor), o RecursiveIteratorIteratorpermite fazer um loop sobre todos os nós em uma árvore ordenada de objetos e seu construtor leva a RecursiveIterator.
Resumindo: RecursiveIteratorIteratorpermite que você faça um loop em uma árvore, IteratorIteratorpermite que você faça um loop em uma lista. Eu mostro isso com alguns exemplos de código abaixo em breve.
Tecnicamente, isso funciona quebrando a linearidade ao percorrer todos os filhos de um nó (se houver). Isso é possível porque, por definição, todos os filhos de um nó são novamente a RecursiveIterator. O nível superior Iteratorentão empilha internamente os diferentes programas RecursiveIteratorpor sua profundidade e mantém um ponteiro para o sub ativo atual Iteratorpara travessia.
Isso permite visitar todos os nós de uma árvore.
Os princípios básicos são os mesmos de IteratorIterator: Uma interface especifica o tipo de iteração e a classe base do iterador é a implementação dessa semântica. Compare com os exemplos abaixo, para loop linear com foreachvocê normalmente não pense muito sobre os detalhes de implementação, a menos que você precise definir um novo Iterator(por exemplo, quando algum tipo concreto não implementa Traversable).
Para traversal recursivo - a menos que você não use um pré-definido Traversalque já tenha iteração traversal recursiva - você normalmente precisa instanciar a RecursiveIteratorIteratoriteração existente ou até mesmo escrever uma iteração traversal recursiva que seja Traversablesua para ter este tipo de iteração traversal foreach.
Dica: Você provavelmente não implementou nem um nem outro por conta própria, então isso pode valer a pena fazer por sua experiência prática das diferenças que eles têm. Você encontra uma sugestão de DIY no final da resposta.
Em resumo, diferenças técnicas:
- Enquanto
IteratorIteratorleva any Traversablepara travessia linear, RecursiveIteratorIteratorprecisa de um RecursiveIteratorloop mais específico para uma árvore.
- Onde
IteratorIteratorexpõe sua Iteratorvia principal getInnerIerator(), RecursiveIteratorIteratorfornece a sub-rotina ativa atual Iteratorapenas por meio desse método.
- Embora não
IteratorIteratoresteja totalmente ciente de nada como pai ou filhos, RecursiveIteratorIteratorsabe como obter e atravessar os filhos também.
IteratorIteratornão precisa de uma pilha de iteradores, RecursiveIteratorIteratortem essa pilha e conhece o sub-iterador ativo.- Onde
IteratorIteratortem sua ordem devido à linearidade e nenhuma escolha, RecursiveIteratorIteratortem uma escolha para travessia adicional e precisa decidir por cada nó (decidido por modo porRecursiveIteratorIterator ).
RecursiveIteratorIteratortem mais métodos do que IteratorIterator.
Para resumir: RecursiveIteratoré um tipo concreto de iteração (looping sobre uma árvore) que funciona em seus próprios iteradores, a saber RecursiveIterator. Esse é o mesmo princípio subjacente de IteratorIerator, mas o tipo de iteração é diferente (ordem linear).
Idealmente, você também pode criar seu próprio conjunto. A única coisa necessária é que seu iterador implemente o Traversableque é possível por meio de Iteratorou IteratorAggregate. Então você pode usá-lo com foreach. Por exemplo, algum tipo de objeto de iteração recursiva de travessia de árvore ternária junto com a interface de iteração correspondente para o (s) objeto (s) recipiente.
Vamos revisar alguns exemplos da vida real que não são tão abstratos. Entre interfaces, iteradores concretos, objetos de contêiner e semântica de iteração, talvez não seja uma ideia tão ruim.
Pegue uma lista de diretórios como exemplo. Considere que você tem o seguinte arquivo e árvore de diretório no disco:
Enquanto um iterador com ordem linear apenas atravessa a pasta e os arquivos de nível superior (uma única listagem de diretório), o iterador recursivo também percorre as subpastas e lista todas as pastas e arquivos (uma listagem de diretório com listagens de seus subdiretórios):
Non-Recursive Recursive
============= =========
[tree] [tree]
├ dirA ├ dirA
└ fileA │ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Você pode facilmente comparar isso com o IteratorIteratorqual não faz recursão para percorrer a árvore de diretórios. E o RecursiveIteratorIteratorque pode penetrar na árvore, conforme mostra a lista Recursiva.
No primeiro um exemplo muito básico com um DirectoryIteratorque implementa Traversableo que permite foreacha iterate sobre ele:
$path = 'tree';
$dir = new DirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
O exemplo de saída para a estrutura de diretório acima é:
[tree]
├ .
├ ..
├ dirA
├ fileA
Como você pode ver, isso ainda não está usando IteratorIteratorou RecursiveIteratorIterator. Em vez disso, basta apenas usar o foreachque opera na Traversableinterface.
Como, foreachpor padrão, só conhece o tipo de iteração chamada ordem linear, podemos querer especificar o tipo de iteração explicitamente. À primeira vista pode parecer muito prolixo, mas para fins de demonstração (e para fazer a diferença com RecursiveIteratorIteratormais visível posteriormente), vamos especificar o tipo linear de iteração especificando explicitamente o IteratorIteratortipo de iteração para a listagem de diretório:
$files = new IteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Este exemplo é quase idêntico ao primeiro, a diferença é que $filesagora é um IteratorIteratortipo de iteração para Traversable $dir:
$files = new IteratorIterator($dir);
Como de costume, o ato de iteração é realizado por foreach:
foreach ($files as $file) {
A saída é exatamente a mesma. Então, o que é diferente? Diferente é o objeto usado no foreach. No primeiro exemplo é um, DirectoryIteratorno segundo exemplo é o IteratorIterator. Isso mostra a flexibilidade que os iteradores têm: você pode substituí-los uns pelos outros, o código interno foreachapenas continua a funcionar conforme o esperado.
Vamos começar a obter a lista completa, incluindo subdiretórios.
Como agora especificamos o tipo de iteração, vamos considerar alterá-lo para outro tipo de iteração.
Sabemos que precisamos atravessar a árvore inteira agora, não apenas o primeiro nível. Para ter esse trabalho com um simples foreachprecisamos de um tipo diferente de iterator: RecursiveIteratorIterator. E isso só pode ser iterado em objetos de contêiner que possuem a RecursiveIteratorinterface .
A interface é um contrato. Qualquer classe que o implemente pode ser usada junto com o RecursiveIteratorIterator. Um exemplo dessa classe é o RecursiveDirectoryIterator, que é algo como a variante recursiva de DirectoryIterator.
Vamos ver um primeiro exemplo de código antes de escrever qualquer outra frase com a palavra I:
$dir = new RecursiveDirectoryIterator($path);
echo "[$path]\n";
foreach ($dir as $file) {
echo " ├ $file\n";
}
Este terceiro exemplo é quase idêntico ao primeiro, no entanto, cria algumas saídas diferentes:
[tree]
├ tree\.
├ tree\..
├ tree\dirA
├ tree\fileA
Ok, não tão diferente, o nome do arquivo agora contém o nome do caminho na frente, mas o resto também parece semelhante.
Como mostra o exemplo, mesmo o objeto diretório já implementa a RecursiveIteratorinterface, isso ainda não é suficiente para fazer foreachpercorrer toda a árvore de diretório. É aqui que o RecursiveIteratorIteratorentra em ação. O Exemplo 4 mostra como:
$files = new RecursiveIteratorIterator($dir);
echo "[$path]\n";
foreach ($files as $file) {
echo " ├ $file\n";
}
Usar o em RecursiveIteratorIteratorvez de apenas o $dirobjeto anterior fará foreachcom que percorra todos os arquivos e diretórios de maneira recursiva. Em seguida, isso lista todos os arquivos, pois o tipo de iteração do objeto foi especificado agora:
[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
Isso já deve demonstrar a diferença entre a travessia plana e em árvore. O RecursiveIteratorIteratoré capaz de percorrer qualquer estrutura semelhante a uma árvore como uma lista de elementos. Como há mais informações (como o nível em que a iteração ocorre atualmente), é possível acessar o objeto iterador ao iterar sobre ele e, por exemplo, indentar a saída:
echo "[$path]\n";
foreach ($files as $file) {
$indent = str_repeat(' ', $files->getDepth());
echo $indent, " ├ $file\n";
}
E o resultado do Exemplo 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
Claro, isso não ganha um concurso de beleza, mas mostra que, com o iterador recursivo, há mais informações disponíveis do que apenas a ordem linear de chave e valor . A Even foreachsó pode expressar esse tipo de linearidade, acessando o próprio iterador permite obter mais informações.
Semelhante à meta-informação, também existem diferentes maneiras possíveis de percorrer a árvore e, portanto, ordenar a saída. Este é o modo deRecursiveIteratorIterator e pode ser definido com o construtor.
O próximo exemplo dirá ao RecursiveDirectoryIteratorpara remover as entradas de pontos ( .e ..), pois não precisamos delas. Mas também o modo de recursão será alterado para levar o elemento pai (o subdiretório) primeiro ( SELF_FIRST) antes dos filhos (os arquivos e sub-subdiretórios no subdiretório):
$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";
}
A saída agora mostra as entradas do subdiretório listadas corretamente, se você comparar com a saída anterior, aquelas não estavam lá:
[tree]
├ tree\dirA
├ tree\dirA\dirB
├ tree\dirA\dirB\fileD
├ tree\dirA\fileB
├ tree\dirA\fileC
├ tree\fileA
O modo de recursão, portanto, controla o que e quando um brach ou folha na árvore é retornado, para o exemplo de diretório:
LEAVES_ONLY (padrão): Listar apenas arquivos, sem diretórios.SELF_FIRST (acima): lista o diretório e os arquivos nele contidos.CHILD_FIRST (sem exemplo): Liste os arquivos no subdiretório primeiro e, em seguida, no diretório.
Saída do Exemplo 5 com os outros dois modos:
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 você compara isso com o percurso padrão, todas essas coisas não estão disponíveis. A iteração recursiva, portanto, é um pouco mais complexa quando você precisa envolvê-la em sua cabeça, no entanto, é fácil de usar porque se comporta como um iterador, você a coloca em um foreache pronto.
Acho que esses são exemplos suficientes para uma resposta. Você pode encontrar o código-fonte completo, bem como um exemplo para exibir árvores ascii de boa aparência nesta essência: https://gist.github.com/3599532
Faça você mesmo: faça o RecursiveTreeIteratortrabalho linha por linha.
O Exemplo 5 demonstrou que há meta-informações disponíveis sobre o estado do iterador. No entanto, esta foi propositadamente demonstrado dentro da foreachiteração. Na vida real, isso pertence naturalmente ao RecursiveIterator.
Um exemplo melhor é o RecursiveTreeIterator, ele cuida de indentação, prefixação e assim por diante. Veja o seguinte fragmento de código:
$dir = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS);
$lines = new RecursiveTreeIterator($dir);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
O RecursiveTreeIteratorobjetivo é trabalhar linha por linha, a saída é bastante direta com um pequeno problema:
[tree]
├ tree\dirA
│ ├ tree\dirA\dirB
│ │ └ tree\dirA\dirB\fileD
│ ├ tree\dirA\fileB
│ └ tree\dirA\fileC
└ tree\fileA
Quando usado em combinação com a RecursiveDirectoryIterator, exibe o nome do caminho completo e não apenas o nome do arquivo. O resto parece bom. Isso ocorre porque os nomes dos arquivos são gerados por SplFileInfo. Esses devem ser exibidos como o nome de base. O resultado desejado é o seguinte:
/// Solved ///
[tree]
├ dirA
│ ├ dirB
│ │ └ fileD
│ ├ fileB
│ └ fileC
└ fileA
Crie uma classe de decorador que pode ser usada com em RecursiveTreeIteratorvez de RecursiveDirectoryIterator. Ele deve fornecer o nome de base do atual em SplFileInfovez do nome do caminho. O fragmento de código final poderia ser assim:
$lines = new RecursiveTreeIterator(
new DiyRecursiveDecorator($dir)
);
$unicodeTreePrefix($lines);
echo "[$path]\n", implode("\n", iterator_to_array($lines));
Esses fragmentos, inclusive, $unicodeTreePrefixsão parte da essência do Apêndice: Faça você mesmo: faça o RecursiveTreeIteratortrabalho linha por linha. .