数组 函数
在线手册:中文  英文

array_shift

(PHP 4, PHP 5)

array_shift 将数组开头的单元移出数组

说明

mixed array_shift ( array &$array )

array_shift()array 的第一个单元移出并作为结果返回,将 array 的长度减一并将所有其它单元向前移动一位。所有的数字键名将改为从零开始计数,文字键名将不变。

Note: 使用此函数后会重置( reset()array 指针。

参数

array

输入的数组。

返回值

返回移出的值,如果 array 为 空或不是一个数组则返回 NULL

范例

Example #1 array_shift() 例子

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

以上例程会输出:

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

并且 orange 被赋给了 $fruit

参见


数组 函数
在线手册:中文  英文

用户评论:

info at chihoang dot de (2011-04-20 09:46:23)

This doesn't work with a 2 dimensional array. With 2 dimensional array I do this:

<?php
$backup 
$arr;
$first array_shift $backup );
?>

ar at xonix dot ch (2010-08-14 03:54:18)

If you need the first or last entry of an array, then this could help you.

<?php
function array_last_entry($arr){
    if(!
is_array($arr))
        return;
    
    if(empty(
$arr))
        return;
        
    return 
end($arr);
}

function 
array_first_entry($arr){
    if(!
is_array($arr))
        return;
        
    if(empty(
$arr))
        return;
        
    
reset($arr);
    return 
current($arr);    
}

$arr = array( '5' => 'five''3' => 'three''8' => 'eight',);

echo 
'last entry: '.array_last_entry($arr).'<br>';

echo 
'first entry: '.array_first_entry($arr).'<br>';

echo 
'alternative output:<br>';
 
echo 
'last entry: '.$arr[count($arr)-1];

echo 
'<br>first entry: '.$arr[0]; 
?>

The output will look like:
last entry: eight
first entry: five
alternative output:
last entry:
first entry: 

As you can see, if you have to handle arrays with non-continuous indexes, these functions may be very helpful.

patrick at pwfisher dot com (2009-08-21 20:23:13)

Here's a utility function to parse command line arguments.

<?php
/**
 * CommandLine class
 *
 * @package             Framework
 */
/**
 * Command Line Interface (CLI) utility class.
 *
 * @author              Patrick Fisher <patrick@pwfisher.com>
 * @since               August 21, 2009
 * @package             Framework
 * @subpackage          Env
 */
class CommandLine {

    
/**
     * PARSE ARGUMENTS
     * 
     * [pfisher ~]$ echo "<?php
     * >     include('CommandLine.php');
     * >     \$args = CommandLine::parseArgs(\$_SERVER['argv']);
     * >     echo "\n", '\$out = '; var_dump(\$args); echo "\n";
     * > ?>" > test.php
     * 
     * [pfisher ~]$ php test.php plain-arg --foo --bar=baz --funny="spam=eggs" --alsofunny=spam=eggs \
     * > 'plain arg 2' -abc -k=value "plain arg 3" --s="original" --s='overwrite' --s
     * 
     * $out = array(12) {
     *   [0]                => string(9) "plain-arg"
     *   ["foo"]            => bool(true)
     *   ["bar"]            => string(3) "baz"
     *   ["funny"]          => string(9) "spam=eggs"
     *   ["alsofunny"]      => string(9) "spam=eggs"
     *   [1]                => string(11) "plain arg 2"
     *   ["a"]              => bool(true)
     *   ["b"]              => bool(true)
     *   ["c"]              => bool(true)
     *   ["k"]              => string(5) "value"
     *   [2]                => string(11) "plain arg 3"
     *   ["s"]              => string(9) "overwrite"
     * }
     *
     * @author              Patrick Fisher <patrick@pwfisher.com>
     * @since               August 21, 2009
     * @see                 http://www.php.net/manual/en/features.commandline.php
     *                      #81042 function arguments($argv) by technorati at gmail dot com, 12-Feb-2008
     *                      #78651 function getArgs($args) by B Crawford, 22-Oct-2007
     * @usage               $args = CommandLine::parseArgs($_SERVER['argv']);
     */
    
public static function parseArgs($argv){
    
        
array_shift($argv);
        
$out                            = array();
        
        foreach (
$argv as $arg){
        
            
// --foo --bar=baz
            
if (substr($arg,0,2) == '--'){
                
$eqPos                  strpos($arg,'=');
                
                
// --foo
                
if ($eqPos === false){
                    
$key                substr($arg,2);
                    
$value              = isset($out[$key]) ? $out[$key] : true;
                    
$out[$key]          = $value;
                }
                
// --bar=baz
                
else {
                    
$key                substr($arg,2,$eqPos-2);
                    
$value              substr($arg,$eqPos+1);
                    
$out[$key]          = $value;
                }
            }
            
// -k=value -abc
            
else if (substr($arg,0,1) == '-'){
            
                
// -k=value
                
if (substr($arg,2,1) == '='){
                    
$key                substr($arg,1,1);
                    
$value              substr($arg,3);
                    
$out[$key]          = $value;
                }
                
// -abc
                
else {
                    
$chars              str_split(substr($arg,1));
                    foreach (
$chars as $char){
                        
$key            $char;
                        
$value          = isset($out[$key]) ? $out[$key] : true;
                        
$out[$key]      = $value;
                    }
                }
            }
            
// plain-arg
            
else {
                
$value                  $arg;
                
$out[]                  = $value;
            }
        }
        return 
$out;
    }
}
?>

regs at voidship dot net (2008-11-03 12:50:27)

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 (2008-10-05 18:06:30)

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 (2008-09-07 22:08:22)

// 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 (2008-07-02 05:15:26)

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 (2008-02-19 09:43:11)

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 (2007-10-02 21:17:13)

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 (2007-09-18 14:04:54)

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 (2007-08-08 01:54:31)

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 (2007-07-09 10:52:22)

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 (2007-04-30 16:52:07)

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.

richard at happymango dot me dot uk (2007-04-12 06:09:39)

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

alreece45 at yahoo dot com (2006-08-09 20:13:36)

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 (2006-05-31 07:27:33)

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.

(2005-09-19 19:57:30)

<?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 (2005-07-27 05:48:34)

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 (2005-04-20 06:24:30)

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;
}

(2005-02-09 04:27:42)

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 (2004-12-14 11:26:00)

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 (2003-03-13 10:55:11)

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)

易百教程