Outra maneira mais simplificada de converter a estrutura plana do $treeem uma hierarquia. Apenas uma matriz temporária é necessária para expô-lo:
// add children to parents
$flat = array(); # temporary array
foreach ($tree as $name => $parent)
{
$flat[$name]['name'] = $name; # self
if (NULL === $parent)
{
# no parent, is root element, assign it to $tree
$tree = &$flat[$name];
}
else
{
# has parent, add self as child
$flat[$parent]['children'][] = &$flat[$name];
}
}
unset($flat);
Isso é tudo para obter a hierarquia em uma matriz multidimensional:
Array
(
[children] => Array
(
[0] => Array
(
[children] => Array
(
[0] => Array
(
[name] => H
)
[1] => Array
(
[name] => F
)
)
[name] => G
)
[1] => Array
(
[name] => E
[children] => Array
(
[0] => Array
(
[name] => A
)
[1] => Array
(
[children] => Array
(
[0] => Array
(
[name] => B
)
)
[name] => C
)
)
)
)
[name] => D
)
A saída é menos trivial se você quiser evitar a recursão (pode ser um fardo com estruturas grandes).
Sempre quis resolver o "dilema" UL / LI para gerar uma matriz. O dilema é que cada item não sabe se os filhos farão o acompanhamento ou não ou quantos elementos precedentes precisam ser encerrados. Em outra resposta, já resolvi isso usando um RecursiveIteratorIteratore procurando getDepth()e outras meta-informações Iteratorfornecidas por mim : Colocando o modelo de conjunto aninhado em um, <ul>mas ocultando subárvores “fechadas” . Essa resposta mostra também que, com iteradores, você é bastante flexível.
No entanto, essa era uma lista pré-classificada, portanto, não seria adequada para o seu exemplo. Além disso, sempre quis resolver isso para uma espécie de estrutura de árvore padrão e HTMLs <ul>e <li>elementos.
O conceito básico que criei é o seguinte:
TreeNode- Abstrai cada elemento em um TreeNodetipo simples que pode fornecer seu valor (por exemplo Name) e se ele tem ou não filhos.TreeNodesIterator- Um RecursiveIteratorque é capaz de iterar sobre um conjunto (array) desses TreeNodes. Isso é bastante simples, pois o TreeNodetipo já sabe se tem filhos e quais.RecursiveListIterator- A RecursiveIteratorIteratorque tem todos os eventos necessários quando itera recursivamente sobre qualquer tipo de RecursiveIterator:
beginIteration/ endIteration- Início e fim da lista principal.beginElement/ endElement- Início e fim de cada elemento.beginChildren/ endChildren- Início e fim de cada lista de filhos. Isso RecursiveListIteratorsó fornece esses eventos na forma de chamadas de função. listas filhas, como é típico para <ul><li>listas, são abertas e fechadas dentro de seu <li>elemento pai . Portanto, o endElementevento é disparado após o endChildrenevento correspondente. Isso pode ser alterado ou configurado para ampliar o uso dessa classe. Os eventos são distribuídos como chamadas de função para um objeto decorador, para manter as coisas separadas.
ListDecorator- Uma classe "decorador" que é apenas um receptor dos eventos de RecursiveListIterator.
Eu começo com a lógica de saída principal. Considerando a $treematriz agora hierárquica , o código final se parece com o seguinte:
$root = new TreeNode($tree);
$it = new TreeNodesIterator(array($root));
$rit = new RecursiveListIterator($it);
$decor = new ListDecorator($rit);
$rit->addDecorator($decor);
foreach($rit as $item)
{
$inset = $decor->inset(1);
printf("%s%s\n", $inset, $item->getName());
}
Olhar Primeiro vamos para o ListDecoratorque simplesmente envolve os <ul>e <li>elementos e é decidir sobre a forma como a estrutura da lista é a saída:
class ListDecorator
{
private $iterator;
public function __construct(RecursiveListIterator $iterator)
{
$this->iterator = $iterator;
}
public function inset($add = 0)
{
return str_repeat(' ', $this->iterator->getDepth()*2+$add);
}
O construtor pega o iterador de lista no qual está trabalhando. inseté apenas uma função auxiliar para uma boa indentação da saída. O resto são apenas as funções de saída para cada evento:
public function beginElement()
{
printf("%s<li>\n", $this->inset());
}
public function endElement()
{
printf("%s</li>\n", $this->inset());
}
public function beginChildren()
{
printf("%s<ul>\n", $this->inset(-1));
}
public function endChildren()
{
printf("%s</ul>\n", $this->inset(-1));
}
public function beginIteration()
{
printf("%s<ul>\n", $this->inset());
}
public function endIteration()
{
printf("%s</ul>\n", $this->inset());
}
}
Com essas funções de saída em mente, este é o resumo / loop de saída principal novamente, passo a passo:
$root = new TreeNode($tree);
Crie a raiz TreeNodeque será usada para iniciar a iteração em:
$it = new TreeNodesIterator(array($root));
Este TreeNodesIteratoré um RecursiveIteratorque permite a iteração recursiva sobre o único $rootnó. É passado como um array porque essa classe precisa de algo para iterar e permite a reutilização com um conjunto de filhos que também é um array de TreeNodeelementos.
$rit = new RecursiveListIterator($it);
Este RecursiveListIteratoré um RecursiveIteratorIteratorque fornece os referidos eventos. Para fazer uso dele, apenas um ListDecoratorprecisa ser fornecido (a classe acima) e atribuído com addDecorator:
$decor = new ListDecorator($rit);
$rit->addDecorator($decor);
Em seguida, tudo é configurado para apenas foreachsobre ele e a saída de cada nó:
foreach($rit as $item)
{
$inset = $decor->inset(1);
printf("%s%s\n", $inset, $item->getName());
}
Como mostra este exemplo, toda a lógica de saída é encapsulada na ListDecoratorclasse e neste único foreach. Todo o percurso recursivo foi totalmente encapsulado em iteradores recursivos SPL que forneceram um procedimento empilhado, o que significa que internamente nenhuma chamada de função de recursão é feita.
O evento baseado em ListDecoratorpermite que você modifique a saída especificamente e forneça vários tipos de listas para a mesma estrutura de dados. É ainda possível alterar a entrada conforme os dados do array foram encapsulados em TreeNode.
O exemplo de código completo:
<?php
namespace My;
$tree = array('H' => 'G', 'F' => 'G', 'G' => 'D', 'E' => 'D', 'A' => 'E', 'B' => 'C', 'C' => 'E', 'D' => null);
// add children to parents
$flat = array(); # temporary array
foreach ($tree as $name => $parent)
{
$flat[$name]['name'] = $name; # self
if (NULL === $parent)
{
# no parent, is root element, assign it to $tree
$tree = &$flat[$name];
}
else
{
# has parent, add self as child
$flat[$parent]['children'][] = &$flat[$name];
}
}
unset($flat);
class TreeNode
{
protected $data;
public function __construct(array $element)
{
if (!isset($element['name']))
throw new InvalidArgumentException('Element has no name.');
if (isset($element['children']) && !is_array($element['children']))
throw new InvalidArgumentException('Element has invalid children.');
$this->data = $element;
}
public function getName()
{
return $this->data['name'];
}
public function hasChildren()
{
return isset($this->data['children']) && count($this->data['children']);
}
/**
* @return array of child TreeNode elements
*/
public function getChildren()
{
$children = $this->hasChildren() ? $this->data['children'] : array();
$class = get_called_class();
foreach($children as &$element)
{
$element = new $class($element);
}
unset($element);
return $children;
}
}
class TreeNodesIterator implements \RecursiveIterator
{
private $nodes;
public function __construct(array $nodes)
{
$this->nodes = new \ArrayIterator($nodes);
}
public function getInnerIterator()
{
return $this->nodes;
}
public function getChildren()
{
return new TreeNodesIterator($this->nodes->current()->getChildren());
}
public function hasChildren()
{
return $this->nodes->current()->hasChildren();
}
public function rewind()
{
$this->nodes->rewind();
}
public function valid()
{
return $this->nodes->valid();
}
public function current()
{
return $this->nodes->current();
}
public function key()
{
return $this->nodes->key();
}
public function next()
{
return $this->nodes->next();
}
}
class RecursiveListIterator extends \RecursiveIteratorIterator
{
private $elements;
/**
* @var ListDecorator
*/
private $decorator;
public function addDecorator(ListDecorator $decorator)
{
$this->decorator = $decorator;
}
public function __construct($iterator, $mode = \RecursiveIteratorIterator::SELF_FIRST, $flags = 0)
{
parent::__construct($iterator, $mode, $flags);
}
private function event($name)
{
// event debug code: printf("--- %'.-20s --- (Depth: %d, Element: %d)\n", $name, $this->getDepth(), @$this->elements[$this->getDepth()]);
$callback = array($this->decorator, $name);
is_callable($callback) && call_user_func($callback);
}
public function beginElement()
{
$this->event('beginElement');
}
public function beginChildren()
{
$this->event('beginChildren');
}
public function endChildren()
{
$this->testEndElement();
$this->event('endChildren');
}
private function testEndElement($depthOffset = 0)
{
$depth = $this->getDepth() + $depthOffset;
isset($this->elements[$depth]) || $this->elements[$depth] = 0;
$this->elements[$depth] && $this->event('endElement');
}
public function nextElement()
{
$this->testEndElement();
$this->event('{nextElement}');
$this->event('beginElement');
$this->elements[$this->getDepth()] = 1;
}
public function beginIteration()
{
$this->event('beginIteration');
}
public function endIteration()
{
$this->testEndElement();
$this->event('endIteration');
}
}
class ListDecorator
{
private $iterator;
public function __construct(RecursiveListIterator $iterator)
{
$this->iterator = $iterator;
}
public function inset($add = 0)
{
return str_repeat(' ', $this->iterator->getDepth()*2+$add);
}
public function beginElement()
{
printf("%s<li>\n", $this->inset(1));
}
public function endElement()
{
printf("%s</li>\n", $this->inset(1));
}
public function beginChildren()
{
printf("%s<ul>\n", $this->inset());
}
public function endChildren()
{
printf("%s</ul>\n", $this->inset());
}
public function beginIteration()
{
printf("%s<ul>\n", $this->inset());
}
public function endIteration()
{
printf("%s</ul>\n", $this->inset());
}
}
$root = new TreeNode($tree);
$it = new TreeNodesIterator(array($root));
$rit = new RecursiveListIterator($it);
$decor = new ListDecorator($rit);
$rit->addDecorator($decor);
foreach($rit as $item)
{
$inset = $decor->inset(2);
printf("%s%s\n", $inset, $item->getName());
}
Outpupt:
<ul>
<li>
D
<ul>
<li>
G
<ul>
<li>
H
</li>
<li>
F
</li>
</ul>
</li>
<li>
E
<ul>
</li>
<li>
A
</li>
<li>
C
<ul>
<li>
B
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
Demonstração (variante do PHP 5.2)
Uma possível variante seria um iterador que itera sobre qualquer um RecursiveIteratore fornece uma iteração sobre todos os eventos que podem ocorrer. Um switch / case dentro do loop foreach poderia então lidar com os eventos.
Relacionado: