array_sum

array_slice

Last updated: Fri, 30 Oct 2009

array_splice

(PHP 4, PHP 5)

array_splice — Remove a portion of the array and replace it with something else

Description

array array_splice ( array &$input , int $offset [, int $length = 0 [, mixed $replacement ]] )

Removes the elements designated by offset and length from the input array, and replaces them with the elements of the replacement array, if supplied.

Note that numeric keys in input are not preserved.

Note: If replacement is not an array, it will be typecast to one (i.e. (array) $parameter). This may result in unexpected behavior when using an object replacement .

Parameters

input

The input array.

offset

If offset is positive then the start of removed portion is at that offset from the beginning of the input array. If offset is negative then it starts that far from the end of the input array.

length

If length is omitted, removes everything from offset to the end of the array. If length is specified and is positive, then that many elements will be removed. If length is specified and is negative then the end of the removed portion will be that many elements from the end of the array. Tip: to remove everything from offset to the end of the array when replacement is also specified, use count($input) for length .

replacement

If replacement array is specified, then the removed elements are replaced with elements from this array.

If offset and length are such that nothing is removed, then the elements from the replacement array are inserted in the place specified by the offset . Note that keys in replacement array are not preserved.

If replacement is just one element it is not necessary to put array() around it, unless the element is an array itself.

Return Values

Returns the array consisting of the extracted elements.

Examples

Example #1 array_splice() examples


<?php
$input = array("red", "green", "blue", "yellow");
array_splice($input, 2);
// $input is now array("red", "green")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, -1);
// $input is now array("red", "yellow")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 1, count($input), "orange");
// $input is now array("red", "orange")

$input = array("red", "green", "blue", "yellow");
array_splice($input, -1, 1, array("black", "maroon"));
// $input is now array("red", "green",
//          "blue", "black", "maroon")

$input = array("red", "green", "blue", "yellow");
array_splice($input, 3, 0, "purple");
// $input is now array("red", "green",
//          "blue", "purple", "yellow");
?>

Example #2 array_splice() examples

The following statements change the values of $input the same way:


<?php
array_push($input, $x, $y);
array_splice($input, count($input), 0, array($x, $y));
array_pop($input);
array_splice($input, -1);
array_shift($input);
array_splice($input, 0, 1);
array_unshift($input, $x, $y);
array_splice($input, 0, 0, array($x, $y));
$input[$x] = $y; // for arrays where key equals offset
array_splice($input, $x, 1, $y);
?>


just useful functions to move an element using array_splice.



<?php



// info at danielecentamore dot com



// $input  (Array) - the array containing the element

// $index (int) - the index of the element you need to move



function moveUp($input,$index) {

      $new_array = $input;

      

       if((count($new_array)>$index) && ($index>0)){

                 array_splice($new_array, $index-1, 0, $input[$index]);

                 array_splice($new_array, $index+1, 1);

             } 



       return $new_array;

}



function moveDown($input,$index) {

       $new_array = $input;

         

       if(count($new_array)>$index) {

                 array_splice($new_array, $index+2, 0, $input[$index]);

                 array_splice($new_array, $index, 1);

             } 

   

       return $new_array;

 }  



$input = array("red", "green", "blue", "yellow");



$newinput = moveUp($input, 2);

// $newinput is array("red", "blue", "green", "yellow")



$input = moveDown($newinput, 1);

// $input is array("red", "green", "blue", "yellow")



?>

strata_ranger at hotmail dot com
01-Jul-2009 04:53


Should you want a similar function for splicing strings together, here is a rough equivalent:



<?php

function str_splice($input, $offset, $length=null, $splice='')

{

  $input = (string)$input;

  $splice = (string)$splice;

  $count = strlen($input);

  

  // Offset handling (negative values measure from end of string)

  if ($offset<0) $offset = $count + $offset;



  // Length handling (positive values measure from $offset; negative, from end of string; omitted = end of string)

  if (is_null($length)) $length = $count;

  elseif ($length < 0)  $length = $count-$offset+$length;



  // Do the splice

  return substr($input, 0, $offset) . $splice . substr($input, $offset+$length);

}



$string = "The fox jumped over the lazy dog.";



// Outputs "The quick brown fox jumped over the lazy dog."

echo str_splice($string, 4, 0, "quick brown ");



?>



Obviously this is not for cases where all you need to do is a simple search-and-replace.

dead dot screamer at seznam dot cz
12-Feb-2009 11:28


I need <?php array_Splice()?> function, that use array keys instead of order (offset and length) because of associated arrays, and this is result:



<?php

/**

 *    first variation

 *

 *    $input is input array

 *    $start is index of slice begin

 *    $end is index of slice end, if this is null, $replacement will be inserted (in the same way as original array_Slice())

 *indexes of $replacement are preserved in both examples

 */

function array_KSplice1(&$input, $start, $end=null, $replacement=null)

{

    $keys=array_Keys($input);

    $values=array_Values($input);

    if($replacement!==null)

    {

        $replacement=(array)$replacement;

        $rKeys=array_Keys($replacement);

        $rValues=array_Values($replacement);

    }



    $start=array_Search($start,$keys,true);

    if($start===false)

        return false;

    if($end!==null)

    {

        $end=array_Search($end,$keys,true);

        // if $end not found, exit

        if($end===false)

            return false;

        // if $end is before $start, exit

        if($end<$start)

            return false;

        // index to length

        $end-=$start-1;

    }



    // optional arguments

    if($replacement!==null)

    {

        array_Splice($keys,$start,$end,$rKeys);

        array_Splice($values,$start,$end,$rValues);

    }

    else

    {

        array_Splice($keys,$start,$end);

        array_Splice($values,$start,$end);

    }



    $input=array_Combine($keys,$values);



    return $input;

}



/**

 *    second variation

 *

 *    $input is input array

 *    $start is index of slice begin

 *    $length is length of slice, what will be replaced, if is zero, $replacement will be inserted (in the same way as original array_Slice())

 */

function array_KSplice2(&$input, $start, $length=0, $replacement=null)

{

    $keys=array_Keys($input);

    $values=array_Values($input);

    if($replacement!==null)

    {

        $replacement=(array)$replacement;

        $rKeys=array_Keys($replacement);

        $rValues=array_Values($replacement);

    }



    $start=array_Search($start,$keys,true);

    if($start===false)

        return false;



    // optional arguments

    if($replacement!==null)

    {

        array_Splice($keys,$start,$length,$rKeys);

        array_Splice($values,$start,$length,$rValues);

    }

    else

    {

        array_Splice($keys,$start,$length);

        array_Splice($values,$start,$length);

    }



    $input=array_Combine($keys,$values);



    return $input;

}



$array=range(1,10);

var_Dump(array_KSplice1($array,3,3,array(100=>101,102,103,104)));



$array=range(1,10);

var_Dump(array_KSplice2($array,3,3,array(100=>101,102,103,104)));



?>



Both examples output:

array(11) {

  [0]=>

  int(1)

  [1]=>

  int(2)

  [2]=>

  int(3)

  [100]=>

  int(101)

  [101]=>

  int(102)

  [102]=>

  int(103)

  [103]=>

  int(104)

  [6]=>

  int(7)

  [7]=>

  int(8)

  [8]=>

  int(9)

  [9]=>

  int(10)

}

Ulrich
01-Nov-2008 11:34


If you have multidimensional array like

<?php

$arr = array(array("a"=>1,"b"=>2),array("a"=>7,"b"=>-34));

?>

you can insert elements using array(array(...)). For example:

<?php

array_splice($arr, 1, 0, array(array("a"=>100, "b"=>77)))

?>

madmax at max-worlds dot net
23-Sep-2008 11:23


Note:  If replacement is not an array, it will be typecast to one (i.e. (array) $parameter). This may result in unexpected behavior when using an object replacement .  





Example :





<?php


class A()


{


    private $a;


    private $b;


    public function __construct()


    {


        $this->a = "foo";


        $this->b = "bar";


    }


}





$array = array();


array_splice($array, 0, 0, new A());


print_r($array);


?>





Outputs :





Array : Array


{


    [0] => foo


    [1] => bar


}





Solution : Enforce the array() on the object.





<?php


array_splice($array, 0, 0, array(new Object());


?>





Source : http://bugs.php.net/bug.php?id=44485

loushou - life dot 42 at gmail dot com
27-Jul-2008 09:39


i miss posted the actual function...

here is the real one lol



<?php



function q_sort(&$Info, $Index, $Left, $Right)

{

  echo "memory usage <b>".memory_get_usage()."</b><br/>\n";

  $L_hold = $Left;

  $R_hold = $Right;

  $Pivot = $Left;

  $PivotValue = $Info[$Left];

  while ($Left < $Right)

  {

    while (($Info[$Right][$Index] >= $PivotValue[$Index]) && ($Left < $Right))

      $Right--;

    if ($Left != $Right)

    {

      $Info[$Left] = $Info[$Right];

      $Left++;

    }

    while (($Info[$Left][$Index] <= $PivotValue[$Index]) && ($Left < $Right))

      $Left++;

    if ($Left != $Right)

    {

      $Info[$Right] = $Info[$Left];

      $Right--;

    }

  }

  $Info[$Left] = $PivotValue;

  $Pivot = $Left;

  $Left = $L_hold;

  $Right = $R_hold;

  if ($Left < $Pivot)

    q_sort($Info, $Index, $Left, $Pivot-1);

  if ($Right > $Pivot)

    q_sort($Info, $Index, $Pivot+1, $Right);

}



?>

Francis
27-Apr-2008 05:27


Do you need to sort a 2D array on just one of its variables while trying to preserve somewhat the original order?





<?php





function sort_2d_array($array, $position, $order = "ASC"){


  if (!is_array($array)) return $array;


  if (count($array) < 2) return $array;


  $new = array($array[0]);


  for ($cnt = 1; $cnt <= count($array) - 1; $cnt++){


    $stop = 0;


    $splice = 0;


    for ($newcnt = 0; $newcnt <= count($new) - 1; $newcnt++){


      if ($stop == 0){


        if ($order == "ASC")


        if ($array[$cnt][$position] < $new[$newcnt][$position]){


          $splice = $newcnt;


          $stop = 1;


        } // splice position for ASC


        if ($order == "DESC")


        if ($array[$cnt][$position] > $new[$newcnt][$position]){


          $splice = $newcnt;


          $stop = 1;


        } // splice position for DESC


      } // stop vying for position


    } // cycle through new array to find position


    if ($stop == 0){ 


      $new[] = $array[$cnt];


    } else {


      array_splice($new, $splice, 0, array($array[$cnt]));


    } // splice into new array while keeping somewhat the original order


  } // cycle through original array


  return $new;


} // sort_2d_array





?>





Application Example: In-House Search Engine


Here we are trying to find the word apple in the website by sort of the most recent occurances first, but the number of occurances first.  





We've already sorted the mysql output by the date desc and have counted the no of occurances and have placed those in an array for the final query.  





I've used this function to further sort the occurances but somewhat keep the original mysql sort order.





Key


[0] Record number


     [0] Record ID


     [1] Source Table


     [2] No of Occurances Pinged





  ---------------------------





[0] 


     [0] 24530


     [1] Blogs


     [2] 1





[1] 


     [0] 24400


     [1] Blogs


     [2] 1





[2] 


     [0] 24240


     [1] Blogs


     [2] 4





[3] 


     [0] 243422


     [1] Classifieds


     [2] 1





[4] 


     [0] 243100


     [1] Classifieds


     [2] 1





After running... 





<?php


sort_2d_array($array, 2, "DESC");


?>





We have...





[0] 


     [0] 24240


     [1] Blogs


     [2] 4





[1] 


     [0] 24530


     [1] Blogs


     [2] 1





[2] 


     [0] 24400


     [1] Blogs


     [2] 1





[3] 


     [0] 243422


     [1] Classifieds


     [2] 1





[4] 


     [0] 243100


     [1] Classifieds


     [2] 1





Might be useful to someone...

nash0r
29-Feb-2008 07:04


array_splice($input, -1) / array_slice($input, 1) equivalent to array_shift($input) ?????





Try this:





<?php


$input = array('key1' => array('deep1' => 'Value'), 'key2' => array('deep2' => 'Value'), 'key3' => array('deep3' => 'Value'));





$foo_splice = array_splice($input, -1);


$foo_shift = array_shift($input);





echo "<pre>".print_r($foo_splice, true)."</pre>";


echo "<pre>".print_r($foo_shift, true)."</pre>";


?>





Output:





Array


(


    [key3] => Array


        (


            [deep3] => Value


        )





)





Array


(


    [deep1] => Value


)

pauljamescampbell at gmail dot com
06-Feb-2008 12:46


Here's my own take on an array slice method that preserves keys from an associative array.





<?php


/**


 * Array slice function that preserves associative keys


 * 


 * @function associativeArraySlice


 *


 * @param  Array  $array  Array to slice


 * @param  Integer  $start    


 * @param  Integer  $end


 * 


 * @return  Array


 */


function associativeArraySlice($array, $start, $end) {


    // Method param restrictions


    if($start < 0) $start = 0;


    if($end > count($array)) $end = count($array);





    // Process vars


    $new = Array();


    $i = 0;





    // Loop


    foreach($array as $key => $value) {


        if($i >= $start && $i < $end) {


            $new[$key] = $value;


        }


        $i++;


    }


    return($new);


}


?>

saurabhmdh at yahoo dot co dot on
15-Sep-2007 05:29


for inserting array in 2-d array, according x position, y position





<?php


function add_module_xy($x_loc, $y_loc, $module) {


    //identify the column of the modules


    switch ($x_loc) {


      case 1:


        $x = 'left';


        break;


      case 2:


        $x = 'middle';


        break;


      case 3:


        $x = 'right';


        break;


      default:


        throw new Exception("", "Invalid horizontal position $x_loc");


    }


    


    $max_y_loc = count($this->module_arrays[$x]) + 1;


    if ($y_loc > $max_y_loc) {


      //if y location is greater then max array index then add module to last


      $y_loc = $max_y_loc;


    }


    $left = array_slice ($this->module_arrays[$x], 0, $y_loc-1);


    $right = array_slice ($this->module_arrays[$x], $y_loc-1);


    $insert[0] = $module;


    $array = array_merge ($left, $insert, $right);


    $this->module_arrays[$x] = $array;





     


  }


?>

mip at ycn dot com
08-Mar-2007 11:37


Ever wounder what array_splice is doing to your references, then try this little script and see the output.



<?php



$a = "a";

$b = "b";

$c = "c";

$d = "d";

$arr = array();

$arr[] =& $a;

$arr[] =& $b;

$arr[] =& $c;

array_splice($arr,1,0,array($d));

$sec_arr = array();

$sec_arr[] =& $d;

array_splice($arr,1,0,$sec_arr);



$arr[0] = "test"; // should be $a

$arr[3] = "test2"; // should be $b

$arr[1] = "this be d?"; // should be $d

$arr[2] = "or this be d?"; // should be $d

var_dump($arr);

var_dump($a);

var_dump($b);

var_dump($d);

?>



The output will be (PHP 4.3.3):



array(5) {

  [0]=>

  &string(4) "test"

  [1]=>

  &string(10) "this be d?"

  [2]=>

  string(13) "or this be d?"

  [3]=>

  &string(5) "test2"

  [4]=>

  &string(1) "c"

}

string(4) "test"

string(5) "test2"

string(10) "this be d?"



So array_splice is reference safe, but you have to be careful about the generation of the replacement array.



have fun, cheers!

ahigerd at stratitec dot com
24-Jan-2007 12:07


A comment on array_merge mentioned that array_splice is faster than array_merge for inserting values. This may be the case, but if your goal is instead to reindex a numeric array, array_values() is the function of choice. Performing the following functions in a 100,000-iteration loop gave me the following times: ($b is a 3-element array)



array_splice($b, count($b)) => 0.410652

$b = array_splice($b, 0) => 0.272513

array_splice($b, 3) => 0.26529

$b = array_merge($b) => 0.233582

$b = array_values($b) => 0.151298

bdjumakov at gmail dot com
31-Aug-2006 05:11


Someone might find this function usefull. It just takes a given element from the array and moves it before given element into the same array.



<?php

function array_move($which, $where, $array)

{

    $tmp  = array_splice($array, $which, 1);

    array_splice($array, $where, 0, $tmp);

    return $array;

}

?>

Paul
12-Feb-2006 04:06


In PHP 4.3.10, at least, it seems that elements that are inserted as part of the replacement array are inserted BY REFERENCE (that is, as though with the =& rather than = assignment operation). So if your replacement array contains elements that references to variables that you can also access via other variable name, then this will be true of the elements in the final array too.



In particular, this means that it is safe to use array_splice() on arrays of objects, as you won't be creating copies of the objects (as it is so easy to do in PHP 4).

gerry-03 at 4warding dot com
10-Feb-2006 01:35


For anybody who is wondering... jrhardytwothousandtwo's trick for inserting an element using array_splice, will also work with multi-dimensional arrays if you do the following:



<?php

  function array_insert(&$input, $offset, $replacement){

    array_splice($input, $offset, 0, 0);

    $input[$offset] = $replacement;

  }

?>



I'm not sure if this (or a derivative of it) will solve other problems that I have seen just about everybody on here trying to solve. But apart from it's hackish nature, it works well for me.

ajd at cloudiness dot com
07-Dec-2005 12:35


weikard's function below is useful but it will still strip keys from array elements where the key is an integer, whether or not it is in a string:



<?php

function array_insert (&$array, $position, $insert_array) {

  $first_array = array_splice ($array, 0, $position);

  $array = array_merge ($first_array, $insert_array, $array);

}

$f = array("three" => "zzz", "3" => "yyy");

$a = array("4.0" => "zzzz", "four" => "yyyy");

array_insert($a,0,$f);

var_dump($a);

// array(4) { ["three"]=> string(3) "zzz" [0]=> string(3) "yyy"  ["4.0"]=> string(4) "zzzz" ["four"]=> string(4) "yyyy" }

?>

weikard at gmx dot de
15-Sep-2005 10:53


You cannot insert with array_splice an array with your own key. array_splice will always insert it with the key "0".





<?php


// [DATA]


$test_array = array (


  row1 => array (col1 => 'foobar!', col2 => 'foobar!'),


  row2 => array (col1 => 'foobar!', col2 => 'foobar!'),


  row3 => array (col1 => 'foobar!', col2 => 'foobar!')


);





// [ACTION]


array_splice ($test_array, 2, 0, array ('rowX' => array ('colX' => 'foobar2')));


echo '<pre>'; print_r ($test_array); echo '</pre>';


?>





[RESULT]





Array (


    [row1] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )





    [row2] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )





    [0] => Array (


            [colX] => foobar2


        )





    [row3] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )


)





But you can use the following function:





function array_insert (&$array, $position, $insert_array) {


  $first_array = array_splice ($array, 0, $position);


  $array = array_merge ($first_array, $insert_array, $array);


}





<?php


// [ACTION]





array_insert ($test_array, 2, array ('rowX' => array ('colX' => 'foobar2')));


echo '<pre>'; print_r ($test_array); echo '</pre>';


?>





[RESULT]





Array (


    [row1] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )





    [row2] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )





    [rowX] => Array (


            [colX] => foobar2


        )





    [row3] => Array (


            [col1] => foobar!


            [col2] => foobar!


        )


)





[NOTE]





The position "0" will insert the array in the first position (like array_shift). If you try a position higher than the langth of the array, you add it to the array like the function array_push.

csaba at alum dot mit dot edu
13-Aug-2005 07:31


Appending arrays


If you have an array $a2 whose values you would like to append to an array $a1 then four methods you could use are listed below in order of increasing time.  The last two methods took significantly more time than the first two.  The most surprising lesson is that using the & incurs a time hit.





<?php


foreach ($a2 as $elem) $a1[]=$elem;


foreach ($a2 as &$elem) $a1[]=$elem;


array_splice ($a1, count($a1), 0, $a2);


$a1 = array_merge($a1, $a2);


?>





Csaba Gabor from Vienna

randomdestination at gmail dot com
22-Jul-2005 06:52


To split an associative array based on it's keys, use this function:



<?php

function &array_split(&$in) {

    $keys = func_get_args();

    array_shift($keys);

    

    $out = array();

    foreach($keys as $key) {

        if(isset($in[$key]))

            $out[$key] = $in[$key];

        else

            $out[$key] = null;

        unset($in[$key]);

    }

    

    return $out;

}

?>



Example: 

<?php

$testin = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4);

$testout =& array_split($testin, 'a', 'b', 'c');



print_r($testin);

print_r($testout);

?>



Will print:



Array

(

    [d] => 4

)

Array

(

    [a] => 1

    [b] => 2

    [c] => 3

)



Hope this helps anyone!

gideon at i6developments dot com
18-Jul-2004 02:45


array_splice dynamically updates the total number of entries into the array. So for instance I had a case where I needed to insert a value into every 4th entry of the array from the back. The problem was when it added the first, because the total number was dynamically updated, it would only add after the 3rd then the 2nd and so one. The solution I found is to track the number of inserts which were done and account for them dynamically. 



Code: 

<?php

    $modarray = array_reverse($mili);

    $trig=1;

        foreach($modarray as $rubber => $glue) {

            if($rubber!="<BR>") {

            $i++;

            $b++;

            if ($i==4) {

                $trig++;

                if($trig<=2) {

                array_splice($modarray,$b,0,"<BR>");

                }elseif($trig>=3){

                array_splice($modarray,$b+($trig-2),0,"<BR>");

                } 

                $i=0;

                };

                };

        };    

    $fixarray = array_reverse($modarray);



?>

jtgt at gmx dot de (Richard Lachmann)
16-Jul-2004 02:18


This function will preserve keys:





<?php


function my_array_splice(&$_arr, $_index, $_long){


           $_keys=array_keys($_arr);


           $_key=array_search($_index, $_keys);


           if ( $_key !== FALSE ){


               $_keys=array_splice($_keys, $_key, $_long);


              foreach ($_keys as $_key) unset($_arr[$_key]);


          }


}


?>

rolandfoxx at yahoo dot com
30-Mar-2004 06:16


Be careful, array_splice does not behave like you might expect should you try to pass it an object as the replacement argument.  Consider the following:



<?php

//Very truncated

class Tree {

  var $childNodes



  function addChild($offset, $node) {

    array_splice($this->childNodes, $offset, 0, $node);

    //...rest of function

  }



}



class Node {

  var $stuff

  ...

}



$tree = new Tree();

// ...set 2 nodes using other functions...

echo (count($tree->childNodes)); //Gives 2

$newNode = new Node();

// ...set node attributes here...

$tree->addChild(1, $newNode);

echo(count($tree->childNodes)); //Expect 3?  wrong!

?>



In this case, the array has a number of items added to it equal to the number of attributes in the new Node object and the values thereof  I.e, if your Node object has 2 attributes with values "foo" and "bar", count($tree->childNodes) will now return 4, with the items "foo" and "bar" added to it.  I'm not sure if this qualifies as a bug, or is just a byproduct of how PHP handles objects.



Here's a workaround for this problem:

function array_insertobj(&$array, $offset, $insert) {

  $firstPart = array_slice($array, 0, $offset);

  $secondPart = array_slice($array, $offset);

  $insertPart = array($insert);

  $array = array_merge($firstPart, $insertPart, $secondPart);

}



Note that this function makes no allowances for when $offset equals the first or last index in the array.  That's because array_unshift and array_push work just fine in those cases.  It's only array_splice that can trip you up.  Obviously, this is kinda tailor-made for arrays with numeric keys when you don't really care what said keys are, but i'm sure you could adapt it for associative arrays if you needed it.

18-Aug-2003 08:57


Want to insert a new value in the middle of the array, without overwriting other elements? Try this.





<?php


$array = array(


    0 => 0,


    1 => 1,


    2 => 2,


    3 => 3,


    4 => 4,


    5 => 5


);


array_splice($array, 3, count($array), array_merge(array('x'), array_slice($array, 3)));


echo '<pre>';


print_r($array);


?>





Output:


Array


(


    [0] => 0


    [1] => 1


    [2] => 2


    [3] => x


    [4] => 3


    [5] => 4


    [6] => 5


)





As you can see, the operation add 'X' in the 4th place, pushing everything else to the next key.

kbrown at horizon dot sk dot ca
11-Aug-2003 05:40


[ Editor's Note: If you're not concerned with the indexes being contiguously numbered (such as for an associative array) then unset($ar[$ind]); will accomplish the same as the code below without requiring splice/splice/merge.  If contiguous numbering IS a concern (such as for indexed arrays), you can still save time by using: unset($ar[$ind]); $ar = array_values($ar); ]





Removing elements from arrays





This works better - much quicker





<?php


$ar = array("einstein", "bert", "colin", "descartes", "renoir");


$a = array_slice($ar, 0, $ind);


$b = array_slice($ar, $ind + 1);


$ar = array_merge($a, $b);


?>

plintus at smtp dot ru
14-Apr-2003 06:59


key-safe:





<?php


function array_kslice ($array, $offset, $length = 0) {


$k = array_slice (array_keys ($array), $offset, $length);


$v = array_slice (array_values ($array), $offset, $length);


for ($i = 0; $i < count ($k); $i ++) $r[$k[$i]] = $v[$i];


return $r;


}


?>





smth like this. hope you like it more than versions above :)

tsunaquake DOESNTLIKESPAM @ wp DOT pl
11-Nov-2002 04:56


It is possible to use a string instead of offset, eg if you want to deletre the entry $myArray['entry'] then you can simply do it like this:





<?php


array_splice($myArray, 'entry', 1);


?>





Note that you can use unset($myArray['entry']) as well but then, it doesn't enable you to remove more than one entry and it doesn't replace anything in the array, if that's what you intend to do.

19-Jun-2002 12:14


Please note that array_splice() 's second argument is an OFFSET and not an INDEX.





Lets say you want to 


$array_of_items = array ('nothing','myitem','hisitem','heritem');


$sid = array_search('myitem',$array_of_items);


echo $sid; /* prints out 1, since index element 1 is "myitem" */





Now, lets say we want to remove that "myitem" from the array:





<?php


$array_of_items = array_splice($array_of_items,(1+$sid),1);


?>





Notice how you have to add a one to the $sid variable?  That is because offset item 1 is "nothing" and since $sid is currently 1 (the index of "myitem"), we add 1 more to it to find out


 its OFFSET.





DO NOT DO THIS:


 $array_of_items = array_splice($array_of_items,$sid,1);

paule at cs dot tamu dot edu
12-Jun-2002 02:59


to kokos@lac.lviv.ua:



Good point about the code not doing what you expected.



The failure to check for the insert case like you pointed out is not a bug, however. I didn't add code to handle that because the key of such an added index is more or less undefined in an unordered associative array. Put another way, if your array is associative and not auto-indexed, you most likely care enough about your keys to want to set them explicitly.

kokos at lac dot lviv dot ua
08-Jun-2002 07:55


To paule@cs.tamu.edu :

Sorry, but the fix will still not work properly - when $length=0 (e.g. trying to insert one value) the

   $new_array[$key]=$replacement;

would be immediately followed by

   $new_array[$key]=$value;

and the $replacement will be lost.



What i was trying to point out in my original post is that $input[$x]=$y is NOT equivalent to array_splice($input, $x, 1, $y) . The equivalence mentioned would be true ONLY when $input is <... ghmm... > "automatically enumerated", having its' keys exactly matching offsets of corresponding elements in the array. But, in general case, keys do not match offsets - perhaps this should be explicitly stated in the Description above.

paule at cs dot tamu dot edu
07-Jun-2002 04:21


Aiya, I feel silly. The fix for my code above assumes that your values in the associative array are strings. Ignore the fix code in my last post and use this instead:





<?php


                if(is_array($replacement))


                    foreach($replacement as $r_key=>$r_value)


                        $new_array[$r_key]=$r_value;


                elseif($replacement!==NULL)


                    $new_array[$key]=$replacement;


?>





Sorry again. I feel sheepish.  n.n

paule at cs dot tamu dot edu
07-Jun-2002 04:09


After reading KoKos' post above, I thought that the code I posted right before his should do what he wanted. However, my original post neglected to note the little "Tip" in the documentation above, about a single element replacement.





If one changes the lines in my code above that says:





<?php


                if(is_array($replacement))


                    foreach($replacement as $r_key=>$r_value)


                        $new_array[$r_key]=$r_value;


?>





to instead say:





<?php


                if(is_string($replacement))


                    $new_array[$key]=$replacement;


                elseif(is_array($replacement))


                    foreach($replacement as $r_key=>$r_value)


                        $new_array[$r_key]=$r_value;


?>





that will solve the problem.





Sorry for the omission.

kokos at lac dot lviv dot ua
07-Jun-2002 01:26


It may seem obvious from the above posts, but cost me a bit of


braindamage to figure this out...





Contrary to the equivalence noted on this page


$input[$x] = $y   <==>   array_splice ($input, $x, 1, $y)


array_splice() will not always work as expected, 


even provided that you have only INTEGER keys!





The following code:


   $t=array('a','b','c','d','e');


   var_dump($t);





<?php


   unset($t[0],$t[1],$t[3]);


   $t[0]='f';


   var_dump($t);





   array_splice($t,0,1,'g');


   var_dump($t);


?>





Will produce:


array(5) {


  [0]=>


  string(1) "a"


  [1]=>


  string(1) "b"


  [2]=>


  string(1) "c"


  [3]=>


  string(1) "d"


  [4]=>


  string(1) "e"


}


array(3) {


  [2]=>


  string(1) "c"


  [4]=>


  string(1) "e"


  [0]=>


  string(1) "f"


}


array(3) {


  [0]=>


  string(1) "g"


  [1]=>


  string(1) "e"


  [2]=>


  string(1) "f"


}





Note the position of $t[0] in the second call to var_dump().


And of course, array_splice() left it intact, changing $t[2] instead.


This is because it operates the _offset_, not the _index_.  :)


I think that "equivalence note" should be considered buggy.  ;)))





Best wishes.


KoKos.

paule at cs dot tamu dot edu
26-May-2002 12:02


I believe the following is a version of array_slice that solves most of the issues for people that want an associative key offset, rather than an integer.





<?php


function key_array_splice(&$input, $key_ofs, $length=NULL, $replacement=NULL)


{


    // Adjust the length if it was negative or not passed


    if($length===NULL || $length<0)


        $count = $length+count($input);





    // Cycle through the array


    foreach($input as $key=>$value){


        if(!$key_found){


            if($key===$key_ofs){


                $key_found=true;


                if($length!==NULL && $length>=0)


                    $count=$length;


                if(is_array($replacement))


                    foreach($replacement as $r_key=>$r_value)


                        $new_array[$r_key]=$r_value;


            }else


                $new_array[$key]=$value;


        }


        if($key_found){


            if($count>0)


                $ret_array[$key]=$value;


            else


                $new_array[$key]=$value;


        }


        $count--;


    }





    // Finish up


    $input=$new_array;


    return $ret_array;


}


?>





Note that this code needs PHP 4 for the use of the "===" and "!==" operators.

jrhardytwothousandtwo at yahoo dot com
15-Feb-2002 05:54


A reference is made to INSERT'ing into an array here with array_splice, however its not explained very well.  I hope this example will help others find what took me days to research.





<?php


$original_array = array(1,2,3,4,5);


$insert_into_key_position = 3;


$item_to_insert = "blue";





$returned = array_splice($original_array, $insert_into_key_position, 0, $item_to_insert);





// $original_array will now show:





// 1,2,3,blue,4,5


?>





Remember that you are telling the array to insert the element into the KEY position.  Thus the elements start with key 0 and so on 0=>1, 1=>2, 2=>3, 3=>blue, 4=>4, 5=>5.  And walla, you've inserted.  I can't say if this is of any value for named keys, or multidimensional arrays.  However it does work for single dimensional arrays.





$returned should be an empty array as nothing was returned.  This would have substance if you were doing a replace instead.

leingang AT math DOT rutgers DOT edu
16-Jan-2002 01:32


array_splice resets the internal pointer of $input.  In fact, many array functions do this.  Caveat programmor!

add a note