set id for each element in recursive array - php

Question

i want to set an id or index for each element and sub and the sub of the sub and so on
<?php
$data = array(
array(
'title' => 'a',
'children' => array(
array(
'title' => 'a-a',
'children' => array(
array(
'title' => 'a-a-a',
'children' => array(
)
)
)
),
array(
'title' => 'a-b',
'children' => array(
)
)
)
),
array(
'title' => 'b',
'children' => array(
)
)
);
?>
i'm looking for php code or function that work with recursion to add the index key witn number (desc) something like this output
<?php
$data = array(
array(
'index' => 1,
'children' => array(
array(
'index' => 2,
'children' => array(
array(
'index' => 3,
'children' => array(
)
)
)
),
array(
'index' => 4,
'children' => array(
)
)
)
),
array(
'index' => 5,
'children' => array(
)
)
);
?>

Answer 1

Once upon a time there a study that came to the conclusion that the biggest challenges a young padawan-programmer on his quest to become a Jedi-senior-programmers are:
[...] there are three major semantic hurdles which trip up novice imperative programmers. In order they are:
assignment and sequence
recursion / iteration
concurrency
I first encountered this theory in Jeff Atwood's blog entry: Separating Programming Sheep from Non-Programming Goats which is based on the scientific paper: The camel has two humps (working title)
This is the code that achieves what you want (minus the echo calls which are only to visualize the steps easier):
function addIndexRecursive(&$data) {
static $index = 0;
echo "The index is: $index" . PHP_EOL;
foreach ($data as &$item) {
$index++;
echo "The index was incremented: {$index}" . PHP_EOL;
$item = array('index' => $index) + $item;
echo "Add the index to the item with title: {$item['title']}" . PHP_EOL;
if (count($item['children']) > 0) {
echo "This item has children so call the index function" . PHP_EOL;
addIndexRecursive($item['children'], $index);
// this else branch is only for illustration purposes only
} else {
echo "There are no children therefore I stop" . PHP_EOL;
}
}
}
So lets dissect it a bit.
First thing to notice: I pass the array by reference. It's just a matter of taste, I prefer to modify the array directly rather then building another copy.
The static $index will help me keep track of the current index and will be incremented for every item is encountered. Lets see what kind of black magic this static does (according to Variable scope):
A static variable exists only in a local function scope, but it does not lose its value when program execution leaves this scope.
foreach ($data as &$item) again I want the elements to be passed by reference so I can modify them directly in the loop.
Now that we discussed the implementation details lets see what the back-trace of the function would be:
addIndexRecursive was call and the index is: 0
The index was incremented: 1
Add the index to the item with title: a
This item has children so call the function
addIndexRecursive was call and the index is: 1
The index was incremented: 2
Add the index to the item with title: a-a
This item has children so call the function
addIndexRecursive was call and the index is: 2
The index was incremented: 3
Add the index to the item with title: a-a-a
There are no children therefore I stop
The index was incremented: 4
Add the index to the item with title: a-b
There are no children therefore I stop
The index was incremented: 5
Add the index to the item with title: b
There are no children therefore I stop
You will keep running into these kind of problems so the sooner you grasp the recursion concept the better.

Answer 2

This is an example of 'nested arrays' where the individual arrays need:
1) an entry to be added: 'index' => <incrementing number> where there is a 'children' entry in the array.
2) an entry to be removed where: 'title' exists in the array.
As arrays can be 'nested' then 'recursion' is the most appropriate way to process the 'data' array.
I find it easier to modify the array 'in place' rather than build up the 'output' array. Therefore 'array references' (&$arrayEntry) are used quite a lot.
I use the supplied test data and test the 'required' array and 'indexed' array to be equal as regards 'structure'.
This is tested code: PHP 5.3.18 on Windows XP. Working code at: viper-7.com
The function that does the work:
function addChildrenIndex(&$destData, &$idxNew)
{
foreach($destData as $currentKey => &$currentValue) { // pass be reference so i can amend it
if (is_array($currentValue)) { // ensure is 'children' array
if (isset($currentValue['children'])) { // add the 'index' entry
$currentValue['index'] = $idxNew;
$idxNew++;
}
if (isset($currentValue['title'])) { // remove the 'title' entry!
unset($currentValue['title']);
}
// as it is an array we 'recurse' around it - always...
addChildrenIndex($currentValue, $idxNew);
}
}
}
Driving Code:
$idxNew = 1; // starting index.
// COPY the source data so i can test it later if required...
$indexedData = $data; // output array
addChildrenIndex($indexedData, $idxNew); // re-index the array 'in place'
// echo 'Required Array: <pre>';
// print_r($requiredData);
// echo '</pre>';
// echo 'OutputArray: <pre>';
// print_r($indexedData);
// echo '</pre>';
// test array structures to contain same entries...
var_dump($indexedData == $requiredData, 'ARE EQUAL?');
Required Test data: see question
Indexed Output:
Array
(
[0] => Array
(
[children] => Array
(
[0] => Array
(
[children] => Array
(
[0] => Array
(
[children] => Array
(
)
[index] => 3
)
)
[index] => 2
)
[1] => Array
(
[children] => Array
(
)
[index] => 4
)
)
[index] => 1
)
[1] => Array
(
[children] => Array
(
)
[index] => 5
)
)