How can I access an array dimension, based on another array? - php

Question

Using the following code:
<?php
$array = array(
array(
array('a','b'),
array('c')
)
);
$location = array('0','1');
$text = 'd';
?>
How can I achieve the following, if the number of elements in $location[] is unknown?
$array[$location[0]][$location[1]][] = $text;
In other words, how do I go one dimension into $array for each element in $location[] and add $text there.

Answer 1

That can be achieved with:
$array = array(
array(
array('a','b'),
array('c')
)
);
$location = array('0','1');
$text = 'd';
$pointer = &$array;
foreach($location as $index)
{
$pointer = &$pointer[$index];
}
$pointer[] = $text;
unset($pointer);//this is for safety
Last unset is needed - because if you'll forget to do that, you could end with debugging "mysterious" bugs when you'll later use $pointer somewhere in code (that will obviously have momentary side-effect, change your source data and cause bugs, while whole logic will be ok)

Answer 2

To read:
$value = $array;
foreach ($location as $index) {
$value = $value[$index];
}
To write:
$value =& $array;
foreach ($location as $index) {
if (!array_key_exists($value, $index)) {
$value[$index] = array();
}
$value =& $value[$index];
}
$value[] = $text;

Answer 3

As the other answers show, this can be achieved with references. However, references are a tad tricky, and can prove difficult to debug. When performing the same loop twice with different arrays, or when nesting loops, the results can be rather baffling, not to mention that assigning by reference can in some cases also issue an E_DEPRECATED notice (not in this particular example, but you never know how your code will be used further down the line). I'd suggest using a recursive function, for that reason:
function getLocation(array $in, array $location)
{
$in = $in[$location[0]];
if (is_array($in) && count($location) > 1)
{//more than 1 index left
$location = array_slice($location,1);//or use unshift
return getLocation($in, $location);
}
return $in;
}
That would be my suggestion: It's easy to read, understand and maintain
To add something to a given location, you can alter this function to recursively (re-)assign values:
function addToLocation(array $in, array $location, $value)
{
if (count($location) === 1)
{//optionally add is_array checks
$in[$location[0]][] = $value;
return $in;
}
$in[$location[0]] = addToLocation(
$in[$location[0]],
array_slice($location, 1),
$value
);
return $in;
}
The up-sides:
Easier to debug, use and maintain
requires no greater skill set to use (the function signature says it all, really)
safer (no references to tidy up, which is easily forgotten)
recursion is fun :)
The down-sides/tradeoffs:
recursion gives some extra overhead (larger call-stack, local scope stays in memory etc...)
References are faster than accessing arrays by index (which requires a HashTable lookup, though these are O(1) operations, a reference gives you direct access, no lookup required)
As often: defensive code is slightly slower, and more resource intensive. The faster approach is more vulnerable, though and harder to maintain. The choice is yours.