array_slice

array_search

Last updated: Fri, 21 Nov 2008

array_shift

(PHP 4, PHP 5)

array_shift — Shift an element off the beginning of array

Description

mixed array_shift ( array &$array )

array_shift() shifts the first value of the array off and returns it, shortening the array by one element and moving everything down. All numerical array keys will be modified to start counting from zero while literal keys won't be touched.

Note: This function will reset() the array pointer after use.

Parameters

array: The input array.

Return Values

Returns the shifted value, or NULL if array is empty or is not an array.

Examples

Example #1 array_shift() example


<?php
$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);
print_r($stack);
?>

The above example will output:

Array
(
    [0] => banana
    [1] => apple
    [2] => raspberry
)

and orange will be assigned to $fruit.


Using array_shift over larger array was fairly slow.  It sped up as the array shrank, most likely as it has to reindex a smaller data set.



For my purpose, I used array_reverse, then array_pop, which doesn't need to reindex the array and will preserve keys if you want it to (didn't matter in my case).  



Using direct index references, i.e., array_test[$i], was fast, but direct index referencing + unset for destructive operations was about the same speed as array_reverse and array_pop.  It also requires sequential numeric keys.

chris {at} w3style {dot} co {dot} uk
05-Oct-2008 06:06


As pointed out earlier, in PHP4, array_shift() modifies the input array by-reference, but it doesn't return the first element by reference.  This may seem like very unexpected behaviour.  If you're working with a collection of references (in my case XML Nodes) this should do the trick.



<?php



/**

 * This function exhibits the same behaviour is array_shift(), except

 * it returns a reference to the first element of the array instead of a copy.

 *

 * @param array &$array

 * @return mixed

 */

function &array_shift_reference(&$array)

{

  if (count($array) > 0)

  {

    $key = key($array);

    $first =& $array[$key];

  }

  else

  {

    $first = null;

  }

  array_shift($array);

  return $first;

}



class ArrayShiftReferenceTest extends UnitTestCase

{

    

  function testFunctionRemovesFirstElementOfNumericallyIndexedArray()

  {

    $input = array('foo', 'bar');

    array_shift_reference($input);

    $this->assertEqual(array('bar'), $input, '%s: The array should be shifted one element left');

  }



  function testFunctionRemovesFirstElementOfAssociativeArray()

  {

    $input = array('x' => 'foo', 'y' => 'bar');

    array_shift_reference($input);

    $this->assertEqual(array('y' => 'bar'), $input, '%s: The array should be shifted one element left');

  }



  function testFunctionReturnsReferenceToFirstElementOfNumericallyIndexedArray()

  {

    $foo = 'foo';

    $input = array(&$foo, 'bar');

    $first =& array_shift_reference($input);

    $this->assertReference($foo, $first, '%s: The return value should reference the first array element');

  }



  function testFunctionReturnsReferenceToFirstElementOfAssociativeArray()

  {

    $foo = 'foo';

    $input = array('x' => &$foo, 'y' => 'bar');

    $first =& array_shift_reference($input);

    $this->assertReference($foo, $first, '%s: The return value should reference the first array element');

  }



  function testFunctionReturnsNullIfEmptyArrayPassedAsInput()

  {

    $input = array();

    $first = array_shift_reference($input);

    $this->assertNull($first, '%s: Array has no first element so NULL should be returned');

  }



}



?>

sggoyal at gmail dot com
07-Sep-2008 10:08


// To Change order of Array by Saurabh Goyal

    function change_array_order($table,$order)

    {

       //init the new table

       $new_table = array();

       foreach($order as $colname)

       {

          $new_table[$colname] = $table[$colname];

       }

       return $new_table;

    }



if array value like:-

$row = array('usr_id'=>'23','usr_name'=>'Saurabh', 'usr_surname'=>'Goyal','usr_firstname'=>'Saurabh');



//you want change order & show only particular field

change_array_order($row,array('usr_name','usr_firstname',

                                            'usr_surname'));



Regard's



Saurabh Goyal

http://sggoyal.blogspot.com

nospam at dyce dot losethisbit dot com
02-Jul-2008 05:15


Just a useful version which returns a simple array with the first key and value. Porbably a better way of doing it, but it works for me ;-)



<?php



function array_kshift(&$arr)

{

  list($k) = array_keys($arr);

  $r  = array($k=>$arr[$k]);

  unset($arr[$k]);

  return $r;

}



// test it on a simple associative array

$arr = array('x'=>'ball','y'=>'hat','z'=>'apple');



print_r($arr);

print_r(array_kshift($arr));

print_r($arr);



?>



Output:



Array

(

    [x] => ball

    [y] => hat

    [z] => apple

)

Array

(

    [x] => ball

)

Array

(

    [y] => hat

    [z] => apple

)

Maikel
19-Feb-2008 09:43


In response to nando_f at nothingsimple dot com



The example is correct,  array_shift do an unset to first element  because the parameter is passed by reference

Ben
02-Oct-2007 09:17


baughmankr at appstate dot edu, I think this is more efficient.



<?php

function array_shorten($arr)

{

  list($k) = array_keys($arr);

  unset($arr[$k]);

  return $arr;

}

?>

baughmankr at appstate dot edu
18-Sep-2007 02:04


I needed to remove the first set of keys and values from an associative array.  Had to write this function: 



function shortenArray($_arr)

{

    $i=1;

    $_shorter=array();

    foreach ($_arr as $k => $v)

    {

        if ($i != 1)

        {

            $_shorter[$k] = $v;

        }

        $i++;

    }

    return $_shorter;

}

dmhouse at gmail dot com
08-Aug-2007 01:54


If you want a version of array_shift() that works non-destructively (i.e., an easy function to grab the first element of the array without modifying the array), try reset().

Traps
09-Jul-2007 10:52


For those that may be trying to use array_shift() with an array containing references (e.g. working with linked node trees), beware that array_shift() may not work as you expect: it will return a *copy* of the first element of the array, and not the element itself, so your reference will be lost.



The solution is to reference the first element before removing it with array_shift():



<?php



// using only array_shift:

$a = 1;

$array = array(&$a);

$b =& array_shift($array);

$b = 2;

echo "a = $a, b = $b<br>"; // outputs a = 1, b = 2



// solution: referencing the first element first:

$a = 1;

$array = array(&$a);

$b =& $array[0];

array_shift($array);

$b = 2;

echo "a = $a, b = $b<br>"; // outputs a = 2, b = 2



?>

C_Prevost at myob
30-Apr-2007 04:52


no, it demonstrates quite well that it removes the first element in the original array, updating the keys, and that it also returns the original first element.

nando_f at nothingsimple dot com
27-Apr-2007 08:42


I believe the example for array_shift is incorrect.

The print_r has the wrong variable.

-NF

richard at happymango dot me dot uk
12-Apr-2007 06:09


If you want to loop through an array, removing its values one at a time using array_shift() but also want the key as well, try this. 



<?php



while($key = key($array))

{

     $value = array_shift($array);

     //code goes here

}



?>



its like foreach but each time the value is removed from the array so it eventually ends up empty



<?php



//example below



$airports = array

(

    "LGW" => "London Gatwick",

    "LHR" => "London Heathrow",

    "STN" => "London Stanstead"

);



echo count($airports)." Airport in the array<br /><br />";



while($key = key($airports))

{

    $value = array_shift($airports);

    echo $key." is ".$value."<br />";

}



echo "<br />".count($airports)." Airport left in the array";



?>



Example Outputs:



3 Airport in the array



LGW is London Gatwick

LHR is London Heathrow

STN is London Stanstead



0 Airport left in the array

François
27-Oct-2006 08:35


Note that array_shift() can be rather time consuming. Whenever possible, you should consider using array_slice() instead.

Consider the following code :



$monthlyHits = 0;

reset ($hitsArray);

foreach($hitsArray as $visitTime ) {

if ($visitTime < $monthStart ) {

array_shift($hitsArray);

$monthlyHits++;

}

}



This could be replaced by :

$monthlyHits = 0;

reset ($hitsArray);

foreach($hitsArray as $visitTime ) {

if ($visitTime < $monthStart ) {

$monthlyHits++;

}

}

$monthlyHits = array_slice($hitsArray,$monthlyHits);



Here is a benchmark I did on a 10 000 rows array :

First method, 9000 mili-seconds.

Second method, 4 mili-seconds

alreece45 at yahoo dot com
09-Aug-2006 08:13


I haven't really read into it, but if you're complaining about a change in PHP 5.0.5 that made it so you couldn't do:



<?php



$val = array_shift(preg_split());



?>



or



<?php



$val = array_shit(function_that_returns_array);



?>



Then you're not using this function correctly. This function's argument is supposed to be a pointer to a variable. It then modifies that variable and returns a value. When you specify a function, php CAN NOT modify the return value of that function. It should be common sense but apparently its not.



Also, on a efficiency note, you might want to consider using another function such as reset or perhaps making your own function such as below:



<?php



function first_element($array) {



return reset($array);



}



?>



Unless of course for some reason you need to save the microseconds this takes.



}

bmr at ediweb dot org
31-May-2006 07:27


If the array has non-numerical keys, array_shift extracts the first element, whichever is the key, and recompute the numerical keys, if there are any. Ie :



$array = array("c" => "ccc", 0 => "aaa", "d" => "ddd", 5 => "bbb");

$first = array_shift($array);

echo '$first = ' . $first . ', $array = ' . var_export($array, true);



will display :



$first = ccc, $array = array ( 0 => 'aaa', 'd' => 'ddd', 1 => 'bbb', )



It means that array_shift works with associative arrays too, and leaves the keys unchanged if they are non-numerical.

19-Sep-2005 07:57


<?php



//----------------------------------------------------------

// The combination of array_shift/array_unshift 

// greatly simplified a function I created for 

// generating relative paths. Before I found them 

// the algorithm was really squirrely, with multiple 

// if tests, length calculations, nested loops, etc. 

// Great functions.

//----------------------------------------------------------



function create_relative_path($inSourcePath, $inRefPath)

{

    // break strings at slashes

    $s_parts            = explode('/', $inSourcePath);

    $r_parts            = explode('/', $inRefPath);

    

    // delete items up to the first non-equal part

    while ($s_parts[0] === $r_parts[0])

    {

        array_shift($s_parts);

        array_shift($r_parts);

    }

    

    // add wild card to r_parts for each remaining 

    // item of s_parts

    while ($s_parts[0])

    {

        array_unshift($r_parts, '..');

        array_shift($s_parts);

    }

    

    return implode('/', $r_parts);

}



//----------------------------------------------------------

// Example:

//     Given a source path $sp generates the relative 

//     location of $rp. $sp could be assigned using 

//     $_SERVER['PHP_SELF'] but it's hardcoded for 

//     the example.

//----------------------------------------------------------

$sp = '/WebServer/Documents/MyBigProject/php/project_script.php';

$rp = '/WebServer/Documents/MyLibraries/lib_script.php';



// plugging them into the function

$rel_path = create_relative_path($sp, $rp);



// yeilds

'../../../MyLibraries/lib_script.php'



// and it could be used like

include_once(create_relative_path($_SERVER['PHP_SELF'], $rp));

lukasz dot dywicki DEL at gmail dot com
27-Jul-2005 05:48


Im using this function to browse arrays from database. For example data:

<?php

$data = array(

      array('row 1-cell 1','row 1-cell 2'),

      array('row 2-cell 1','row 2-cell 2'),

      array('row 3-cell 1','row 3-cell 2'),

);



while($row=array_shift($data)) {

      echo $row[0];

}

?>

Output:

row 1-cell 1

row 2-cell 1

row 3-cell 1

arturo {dot} ronchi {at} gmail {dot} com
20-Apr-2005 06:24


Here is a little function if you would like to get the top element and rotate the array afterwards.



function array_rotate(&$arr)

{

  $elm = array_shift($arr);

  array_push($arr, $elm);

  return $elm;

}

09-Feb-2005 04:27


This function will save the key values of an array, and it will work in lower versions of PHP:



<?php



function array_shift2(&$array){

    reset($array);

    $key = key($array);

    $removed = $array[$key];

    unset($array[$key]);

    return $removed;

}



?>

James McGuigan
14-Dec-2004 11:26


while(array_shift()) can be used to process multiple arrays and/or database results in a single loop. The || short circuts and only evaluates the first statement until it runs out of data.



It can help to reduce duplicated code (the rule is code once and once only).



Note that each ($row = ) statement much be encased in ()'s otherwise you will get funny results. If you use two array_shift($array) statements and forget the ()'s, you will repeatedly get the first element of the first array for the for the count of the $array.



<?php



require_once('class.db.php');



$sql = "SELECT title FROM links";

$result = mysql_query($sql, $db->connection);



$defaults = array(

     array('title' => 'None'), 

     array('title' => 'Unknown')

);



while ( ($row = mysql_fetch_assoc($result)) 

     || ($row = array_shift($defaults))) 

{

  echo $row['title'] . "<br>";

}



?>



This will print out (depending on database contents):

Title1

Title2

Title3

...

None

Unknown

alex at netflex dot nl
13-Mar-2003 10:55


Hi,





if you want to shift the first element of a large array (more than 10.000?) and it must realy fast then you can use this better:





<?php


reset($array);


list($oldKey, $oldElement) = each($array);


unset($array[$oldKey]);


?>





note: the index wil not be changed (not reindexed)

add a note