[Resolved] Adding element to middle of array. How?

[davidjam]

Hello,

I am attempting to add an element to the middle of an array but see no way of doing it (checked out array functions on php.net). Here's the scenario:

foreach($something as $key => $value) {
     $build[$key] = " .. html ..";
     if($special_var == $key) {
          .. I want the build to be added RIGHT AFTER the position of $key in the $build array ..
     }
}

Thanking all in advance. Grazie molto! 🙂

[Huuggee]

how about using a temporary array to do the work for you.

$temp = array();

foreach($something as $key => $value) {
     $build[$key] = " .. html ..";
     temp[$key] = $value

 if($special_var == $key) {
     temp[$key]=build[$key]
 }
}

// reset orig array
$something = array();
$something = $temp;

this may be a basis, as looking at it, it's going to overwrite one element of $something[] with the same key.

i guess this method may depend on whether you have an assoc array or not too.

[davidjam]

Thanks for the reply. I found a totally different solution anyways.

Although I am rather curious, why amongst all the array functions in PHP there isn't one for inserting a value wherever you want in the array. Maybe I missed it...

Thanks again.

[Installer]

For anyone looking for the same thing, here's a function that will insert into an array,
maintaining associative indexes:

function array_insert_assoc($arr, $new_element, $after_key)
{
    $i = 0;
    foreach ($arr as $key => $value) {
        $i++;
        if ($key == $after_key) {
            $tmp_arr = array_chunk($arr, $i, 1);
            $new_arr = $tmp_arr[0] + $new_element;
            foreach ($tmp_arr as $tmp_key => $tmp_val) {
                if ($tmp_key == 0) {
                    continue;
                }
                $new_arr += $tmp_val;
            }
            return $new_arr;
        }
    }
    return false;
}

// Demo:
$array  = array('first'  => 'one',   'second' => 'two',
                'third'  => 'three', 'fourth' => 'four');
$insert = array('new_key' => 'new value');
$after  = 'second';
$new_array = array_insert_assoc($array, $insert, $after);
if ($new_array) {
    foreach ($new_array as $key => $value) {
        echo $key . ' => ' . $value . '<br />';
    }
} else {
    echo 'Failed';
}

(Tested only on 1D array.)

[davidjam]

That's great! I copied it into my growing little library of clips from this site. Thanks "installer".

[laserlight]

Here's my improvement on Installer's idea that seems to be up to thrice as fast:

function array_insert_assoc($arr, $new_element, $after_key) {
	if (($breakpt = array_search($after_key, array_keys($arr))) !== false) {
		return array_slice($arr, 0, $breakpt + 1) + $new_element + array_slice($arr, $breakpt);
	} else {
		return false;
	}
}

[Installer]

Good one, l.l., but I couldn't resist wasting time checking on the "thrice as fast" claim. 🙂

So with this testing code (PHP5):

$array = array();
$ltr_arr = range('a', 'z');
for ($x = 0; $x < 1000; $x++) {
    $key = '';
    for ($y = 0; $y < 3; $y++) {
        $key_key = array_rand($ltr_arr);
        $key .= $ltr_arr[$key_key];
    }
    $keys[] = $key;
    $array[$key] = 'value';
}
$insert = array('new_key' => 'new value');

$iterations = 10;
$loops = 100;
$time_1 = 0;
$time_2 = 0;

for ($l = 0; $l < $loops; $l++) {
    $after = $keys[rand(0, count($keys))];

$start = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
    $new_array = array_insert_assoc_1($array, $insert, $after);
}
$time_1 += microtime(true) - $start . '<br />';

$start = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
    $new_array = array_insert_assoc_2($array, $insert, $after);
}
$time_2 += microtime(true) - $start . '<br />';
}

echo 'Average time for ' . $iterations . ' iterations(' . $loops . ' loops):<br />';
echo 'Function 1: ' . $time_1 / $loops . ' sec.<br />';
echo 'Function 2: ' . $time_2 / $loops . ' sec.<br />';

...these results (typical of several runs; yours is function 2):

Average time for 10 iterations (100 loops):
Function 1: 0.18609962463379 sec.
Function 2: 0.15152367830277 sec.

(c. 18% faster)

[laserlight]

but I couldn't resist wasting time checking on the "thrice as fast" claim.

Yeah, I checked it again too some time later as I reasoned that it could not possibly be that fast on average, and found out that that particular result was an anomaly.

[Weedpacket]

I assume this is an associative array?

It's a one-function call for an indexed array:

array_splice($the_array, $index_to_insert_at, 0, $the_thing_to_insert);

But this doesn't work for associative arrays, even if you got the offset of the key to insert after and used that as $index_to_insert_at-1, the key from the $thing_to_insert gets lost en route.

Hm... if the key being inserted matches one already present, do you want it to overwrite or not? If you do, do you want the key order to be adjusted, or not?

[laserlight]

But this doesn't work for associative arrays, even if you got the offset of the key to insert after and used that as $index_to_insert_at-1, the key from the $thing_to_insert gets lost en route.

That's why you have to emulate using array_slice() if it isnt numerically indexed.