A tree is a scructure of data used for categories, showing hierarchy and so on. In web applications usually the most used case is creating category hierarchy, menu hierarchy or page hierarchy. Currently there are a lot of ways to create tree scructures in PHP, but we will use just one example, one that is very flexible and adaptable for many usecases.

Example of a tree

For the sake of simplicity, we will use a very simple tree for example. Our tree looks like this:

This is a one depth tree with four nodes in total. In trees, the nodes that have children are called branches and the ones that have none are called leaves.

How to store a tree

When working with simple trees, storing the hierarchy is not that hard. Usually, in the database we can create a parent column that contains the parent of a given node. In tree structures, every node can have only one parent, the only exception being the root. The root node has no parent.

Now, if we know how deep our tree will be, using just the parent for information, we are set. If we do not know the depth exactly, things are a bit more complicated. Since people created databases, a lot of storing methods have been born that help store recursive data linearly. Each is different in a way and each is good at something, but bad at other.

Our example is a basic linear representation and is pretty quick. It contains some extra info that some might consider an overhead, but it is simple, logical, and it works.

This is how we store the data. Every row is a node. The columns are as following:

Id: this is the autoincrement unique id of every node.

Parent: This contains one integer, the Id of the parent node. This is mainly formality and is used in simple cases.

Tree: with this field, we can have more than one tree in one table. This is an integer and is the id of the tree we work with. Every tree has a root node that is mandatory

Slug: this is a slug, created from the given name and is always unique in the table. This is an additional unique field besides the Id.

Name: this is the name of the node.

Path: this column coontains the ids of the nodes that are before our node on the branch from the root, merged into a string. This contains the full path from the root till the node. This is handy in building the hierarchy in PHP.

Children: contains all the ids of the children of a node, merged into a string. This also stores the order of the children.

Handling tree in PHP

In PHP, we can easily manipulate this data. We will have some basic examples to show the perks of this type of DB structure.

For start, how do you get the tree? With one simple query, we can get the whole tree, or just a subtree, using the id of the root node. The nodes that have paths that contain the given id, all belong to the same subtree. This looks like this:

SELECT * FROM `table_name` WHERE 
			`path` LIKE "%-:parent-%"
			OR `path` LIKE "%|:parent-%"
			OR `path` LIKE "%-:parent|%"
			OR `path` LIKE "%|:parent|%"

When we have the data, we have to convert the strings into actual PHP arrays for us to be able to easily use them later. We do this like:

$node->path = array_filter(explode('-', str_replace('|', '', $node->path)));
$node->children = array_filter(explode(',', str_replace('|', '', $node->children)));

$node->path = array_filter(explode('-', str_replace('|', '', $node->path)));
$node->children = array_filter(explode(',', str_replace('|', '', $node->children)));

One other important aspect is moving the nodes from a parent to another, being able to move the whole subtree if necessary. In our case this is not hard, we just have to update some strings. In PHP this means slicing and rearranging our arrays of children and path. Something like this:

// Get old parent
$old_parent = $this->getNode($node->parent);
			
$old_parent->children = array_diff($old_parent->children, array($node->id));
$this->_storage->begin_transaction();
			
try
{
	$this->_storage->updateNode($old_parent);
				
	$arr2 = array_slice($to->children, $order-1);
	$arr1 = array_diff($to->children, $arr2);
	$to->children = array_merge($arr1, array($node->id), $arr2);
				
	$this->_storage->updateNode($to);
				
	$node->parent = $to->id;
	$node->path = array_merge($to->path, array($to->id));
	$this->_storage->updateNode($node);
				
	foreach( $subtree as $subnode )
	{
		$subnode->path = array_merge(
			$to->path,
			array($to->id, $node->id),
			array_diff($subnode->path, array_merge($node->path, array($node->id)))
		);
					
		$this->_storage->updateNode($subnode);
	}
				
	$this->_storage->commit_transaction();
				
	return true;
}
catch(Exception $e)
{
	$this->_storage->rollback_transaction();
	$this->_errors['move'] = $e->getMessage();
	return false;
}

Ordering is also easy. Ordering is done on a given level, so we use the children column to order the nodes. The code would look like this:

$children = array_diff($to->children, array($node->id));
$arr2 = array_slice($children, $order-1);
$arr1 = array_diff($children, $arr2);
$to->children = array_merge($arr1, array($node->id), $arr2);
			
$this->_storage->updateNode($to);

Upon deletion, using the move section, you can prompt the user to move the subtree to root, or delete the whole subtree.

Using LIKE syntax in SQL, you can achieve a lot of things.

One last thing that needs mentioning is the recursive function that builds the N depth out of linear data we just got from DB. Here it is:

private function _build_tree(Node $root, $data)
{
	$mapped_node = array(
		'node' => $root,
		'subnodes' => array()
	);
		
	if ( !empty($root->children) )
	{
		foreach( $root->children as $child )
		{
			if ( array_key_exists($child, $data) )
			{
				$mapped_node['subnodes'][] = $this->_build_tree($data[$child], $data);
			}
		}
	}
		
	return $mapped_node;
}

Conclusion

You can find all these pieces of code in the PHPInfinityTree repository on GitLab. This is probably not the best solution, but is simple, understandable and is quick. Since recursivity cannot be used in many databases, we have to store the data linearly. Then we go trough it linearly and build up the tree itself.

You can find a working example on PHPInfinityTree.

Also, you can find the packed and documented package of Infinity Tree in the Store.

If you create a small project, using this technique is totally ok. The problem starts when the project starts to grow.

This article is about a small sized project with very few PHP files. In any case, readability is a very important thing. You know the case when you get back to your code after a long time to edit something, and you just are lost. To make the code readable and logically sound, there is a structure that can be used to achieve it.

If the PHP file contains HTML in it, usually it is good to separate the two. The file starts with PHP, containing all the logic needed. All the data that needs to be printed on the screen is added into variables. These variables are then used in the HTML. This clearly separates the logic from the actual data output. So the structure looks something like:

<?php 
// PHP code here $variable = 'Hello, world'; 
$variable = 'Hello, world!';
?>
<!-- HTML part here -->
<div><?php echo $variable; ?></div>

In the PHP section, where the logic is, you can also separate the logic that handles POST requests for example. It is good practice to create variables that will control such events and that hold information about these events. These variables than can control the HTML part accordingly. For example:

 <?php
$error = '';
$post_var = '';
$was_post = false;
// Some data collecting logic
$variable = 'Hello, world!';
if ($_POST)
{
    $error = 'Sample error.';
    $post_var = 'Goodbye';
    $was_post = true;
}
?>
<?php if ($error != ''): ?>
    <div style="color:red;"><?php echo $error; ?></div>
<?php endif! ?>
<div><?php echo $variable; ?></div>
<?php if ( $was_post ): ?>
    <div><?php echo $post_var; ?></div>
<?php endif; ?>
<form action="" method="post">
    <input type="submit" value="POST">
</form>

This makes your code clear and if needed, later you can separate the logic from the actual html. Using such a structure is beneficial for you. Since PHP is a very loose language, you are the one that needs to pay attention to such things, but you will not regret it.