Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Function Reference : Array Functions : array_reverse

array_reverse

Return an array with elements in reverse order (PHP 4, PHP 5)
array array_reverse ( array array [, bool preserve_keys] )

array_reverse() takes input array and returns a new array with the order of the elements reversed, preserving the keys if preserve_keys is TRUE.

Example274.array_reverse() example

<?php
$input
= array("php", 4.0, array("green", "red"));
$result = array_reverse($input);
$result_keyed = array_reverse($input, true);
?>

This makes both $result and $result_keyed have the same elements, but note the difference between the keys. The printout of $result and $result_keyed will be:

Array
(
[
0] => Array
(
[
0] => green
[1] => red
)

[
1] => 4
[2] => php
)
Array
(
[
2] => Array
(
[
0] => green
[1] => red
)

[
1] => 4
[0] => php
) ?>


Note:

The second parameter was added in PHP 4.0.3.

See also array_flip().

Related Examples ( Source code ) » array_reverse



Code Examples / Notes » array_reverse

ella

You can also use array_reverse to reset array indexes without losing the order of the values. For example when you use unset() to delete values from an array, the value gets deleted but you end up with a missing index:
$array[0] = 'record1';
$array[9] = 'record2';
$array[15] = 'record3';
Just use:
$array = array_reverse(array_reverse($array));
And your indexes get rearranged:
$array[0] = 'record1';
$array[1] = 'record2';
$array[2] = 'record3';


david

With associative arrays array_reverse() keeps key => value pairs matched but reverses the order of the array as spaned by functions like each().  With numerical indexes array_reverse not only reverses position (as spaned by each) but also renumbers the keys.
Both cases seem to be what people would generally want: indeed without the renumbering behavior, someone refering to array elements by numerical key wouldn't think array_reverse did anything.
However, people who are trying to keep numerical keys associated with their values - e.g. trying to have holes in their arrays - will be foiled by the renumbering.  The most telling results come from applying array_reverse() to arrays with mixed keys (some numbers and some strings).  The strings stay attached and the rest of the keys get renumbered around them - most annoying if you are thinking what you've got is an associative array but some of your keys happen to be numbers.


rahulavhad

This code can help in recursive reversing of the array...
<?php
$arr1 = array(2,1,array(5,2,1,array(9,8,7)),5,0);
$arr1 = array_reverse($arr1);
function Reverse_Array($array)
{ $index = 0;
foreach ($array as $subarray)
{ if (is_array($subarray))
{ $subarray = array_reverse($subarray);
$arr = Reverse_Array($subarray);
$array[$index] = $arr;
}
else {$array[$index] = $subarray;}
$index++;
}
return $array;
}
$arr2 = Reverse_Array($arr1);
?>


m dot weber

If you want to reverse an array with numerical indexes, you can keep them by using following code:
<?php
end($gruppenarr);
do {
 $part1=key($gruppenarr);
 $part2=current($gruppenarr);
 $gruppenarr2[$part1]=$part2;
} while(prev($gruppenarr));
?>
input is $gruppenarr
output is $gruppenarr2


michiel de roo

If you need to reverse an array by reference, you can use the following function.
<?
function &array_reverse_ref(&$a) {
$r = array();
for($i=0, $j=count($a); $i<count($a); $i++, $j--) {
$r[$i] =& $a[$j-1];
}
return $r;
}
?>
Use it like:
<?
class t {
var $message = "message";
}
for($i=0; $i<10; $i++) {
$a[] = new t();
}
$ra =& array_reverse_ref($a);
$a[0]->message = "now... this works in both";
$ra[0]->message = "but.... does not work in both";
for($i=0; $i<10; $i++) {
echo $ra[$i]->message; echo "
\n";
}
echo "
\n";
for($i=0; $i<10; $i++) {
echo $a[$i]->message; echo "
\n";
}
?>


me2resh

Here is my version of sorting multidimensional arrays with any key in it even if u want it alphapatically sorted by any key.
u can remove the strtolower part if you want to keep it case sensitive
function cmp($a, $b){
   return strcmp(strtolower($a["name"]), strtolower($b["name"]));
}


nospam dot nass

For a similar functionality in PHP3, use something like:
for ($i = count ($foo) - 1 ; $i >= 0; $i-- ) {
do something here
}
... where $foo is the array that you want to reverse.


rdx

As response to Ella's note:
$array[0] = 'record1';
$array[9] = 'record2';
$array[15] = 'record3';
That is ordered way easier AND faster with array_values().
array_reverse twice is unnecessary. Once array_values and all values will be saved in new keys


david

As a further clarification: key-value pairs have an order within an array completely separate from whatever the keys happen to be - the order in which you add them.  This is the order that functions like each() and next() will move their pointer through the array.
If you add to an array without specifying the key, like $array[] = value; then an internal counter supplies the key value and then the numerical order of your keys will be identical to the the internal order.  If you "leave holes" - jumping ahead by specifying a higher number for the key, like $array[1000] = value; the internal counter gets pushed forward appropriately.  Other than its effect on this internal counter, specifying a numerical key seems no different than specifying a string.
However, some array functions, like array_merge() and array_reverse() treat keys that are numbers differently from keys that are not.


zee4speed

another way to ->
If you want to reverse an array with numerical indexes, you can keep them by using following code:
<?
# this is your array, and you would like to reverse it however maintain their actual index values to point to the existings.
$array_to_reverse[0]="zee";
$array_to_reverse[1]="andrew";
$array_to_reverse[2]="pablo";
$array_to_reverse[3]="mike";
$array_to_reverse[4]="ahmed";
$array_to_reverse[5]="yousra";
$array_to_reverse[6]="samir";
# you want the array to look like this so you can use a command like for each to march through the array.
$array_reversed[6]="samir";
$array_reversed[5]="yousra";
$array_reversed[4]="ahmed";
$array_reversed[3]="mike";
$array_reversed[2]="pablo";
$array_reversed[1]="andrew";
$array_reversed[0]="zee";
# however if you use array_reverse you get this:
$array_reversed[0]="samir";
$array_reversed[1]="yousra";
$array_reversed[2]="ahmed";
$array_reversed[3]="mike";
$array_reversed[4]="pablo";
$array_reversed[5]="andrew";
$array_reversed[6]="zee";
# this causes element samir to be first instead of last, just like you want.  hoever, the index value that refferences samir is now 0 instead of 6
# solution to this is the following code
$array_reversed = array_reverse ($array_to_reverse);
$size_of_array = count($array_reversed);
for ($z = 0; $z < $size_of_array; $z++){
    #do what you want
    #if you want to get the index value of the un-reveresed array, simply
    $actual_index = GetActualIndex($z,$size_of_array);
    echo $z." on array_reversed is the same ".$actual_index." on array_to_reverse
\n";
}
function GetActualIndex($current_index, $size_of_array){
    $reverse_location = abs($current_index + 1 - $size_of_array);
    return $reverse_location;
}
?>


Change Language


Follow Navioo On Twitter
array_change_key_case
array_chunk
array_combine
array_count_values
array_diff_assoc
array_diff_key
array_diff_uassoc
array_diff_ukey
array_diff
array_fill_keys
array_fill
array_filter
array_flip
array_intersect_assoc
array_intersect_key
array_intersect_uassoc
array_intersect_ukey
array_intersect
array_key_exists
array_keys
array_map
array_merge_recursive
array_merge
array_multisort
array_pad
array_pop
array_product
array_push
array_rand
array_reduce
array_reverse
array_search
array_shift
array_slice
array_splice
array_sum
array_udiff_assoc
array_udiff_uassoc
array_udiff
array_uintersect_assoc
array_uintersect_uassoc
array_uintersect
array_unique
array_unshift
array_values
array_walk_recursive
array_walk
array
arsort
asort
compact
count
current
each
end
extract
in_array
key
krsort
ksort
list
natcasesort
natsort
next
pos
prev
range
reset
rsort
shuffle
sizeof
sort
uasort
uksort
usort
eXTReMe Tracker