Php массив обратный порядок

Understanding the PHP Array Reverse Function

In PHP, the array_reverse() function is an in-built function that allows you to reverse the order of elements in an array. This function can be used to reverse the order of elements in both associative and indexed arrays. In this article, we will be taking an in-depth look at the array_reverse() function and how it can be used to effectively manipulate arrays in PHP.

How Does the PHP Array Reverse Function Work?

The array_reverse() function takes an array as its argument and returns a new array with its elements in reverse order. The original array remains unchanged. It is important to note that this function only reverses the order of elements in the array and not their keys. If the original array is an associative array, the keys of the reversed array will still correspond to the original keys, but the order of elements will be reversed.

Here is an example of how the array_reverse() function can be used:

 $original_array = array("apple", "banana", "cherry"); $reversed_array = array_reverse($original_array); print_r($reversed_array); ?>

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

As we can see, the order of elements in the $reversed_array is the reverse of the order of elements in the $original_array .

Using the PHP Array Reverse Function with Associative Arrays

As mentioned earlier, the array_reverse() function can also be used with associative arrays. When used with associative arrays, the order of elements in the reversed array is reversed, but the keys of the elements remain the same.

Here is an example of how the array_reverse() function can be used with an associative array:

 $original_array = array("a" => "apple", "b" => "banana", "c" => "cherry"); $reversed_array = array_reverse($original_array); print_r($reversed_array); ?>

Array ( [c] => cherry [b] => banana [a] => apple )

As we can see, the keys of the elements in the $reversed_array still correspond to the original keys, but the order of elements is reversed.

Conclusion

In conclusion, the array_reverse() function is a powerful and versatile function that allows you to easily reverse the order of elements in an array. Whether you are working with indexed arrays or associative arrays, the array_reverse() function can help you to manipulate your arrays in the way that you need. With its simple syntax and straightforward behavior, the array_reverse() function is an essential tool for any PHP programmer working with arrays.

Источник

array_reverse

Принимает массив array и возвращает новый массив, содержащий элементы исходного массива в обратном порядке.

Список параметров

Если установлено в true , то числовые ключи будут сохранены. Нечисловые ключи не подвержены этой опции и всегда сохраняются.

Возвращаемые значения

Возвращает массив с элементами в обратном порядке.

Примеры

Пример #1 Пример использования array_reverse()

$input = array( «php» , 4.0 , array( «green» , «red» ));
$reversed = array_reverse ( $input );
$preserved = array_reverse ( $input , true );

print_r ( $input );
print_r ( $reversed );
print_r ( $preserved );
?>

Результат выполнения данного примера:

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

Смотрите также

User Contributed Notes

• Функции для работы с массивами
  • array_​change_​key_​case
  • array_​chunk
  • array_​column
  • 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_​is_​list
  • array_​key_​exists
  • array_​key_​first
  • array_​key_​last
  • array_​keys
  • array_​map
  • array_​merge_​recursive
  • array_​merge
  • array_​multisort
  • array_​pad
  • array_​pop
  • array_​product
  • array_​push
  • array_​rand
  • array_​reduce
  • array_​replace_​recursive
  • array_​replace
  • 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
  • end
  • extract
  • in_​array
  • key_​exists
  • key
  • krsort
  • ksort
  • list
  • natcasesort
  • natsort
  • next
  • pos
  • prev
  • range
  • reset
  • rsort
  • shuffle
  • sizeof
  • sort
  • uasort
  • uksort
  • usort
  • each

  Источник

  Смотрите также

  A simple trick that can help you to guess what diff/intersect or sort function does by name.

  [suffix] assoc — additional index check. Compares both value and index.

  Example: array_diff_assoc, array_intersect_assoc.

  [suffix] key — index only check. Ignores value of array, compares only indexes.

  Example: array_diff_key, array_intersect_key.

  [suffix] **empty** — no «key» or «assoc» word in suffix. Compares values only. Ignores indexes of array.

  Example: array_diff, array_intersect.

  [prefix] u — will do comparison with user defined function. Letter u can be used twice in some functions (like array_udiff_uassoc), this means that you have to use 2 functions (one for value, one for index).

  Example: array_udiff_uassoc, array_uintersect_assoc.

  This also works with array sort functions:

  [prefix] a — associative. Will preserve keys. [prefix] k — key sort. Will sort array by keys. [prefix] r — reverse. Will sort array in reverse order. [prefix] u — sort by user defined function (same as for diff/intersect).

  Big arrays use a lot of memory possibly resulting in memory limit errors. You can reduce memory usage on your script by destroying them as soon as you´re done with them. I was able to get over a few megabytes of memory by simply destroying some variables I didn´t use anymore.
  You can view the memory usage/gain by using the funcion memory_get_usage(). Hope this helps!

  I need to take an element from the Array and change its position within the Array by moving the rest of the elements as required.
  This is the function that does it. The first parameter is the working Array. The second is the position of the element to move and the third is the position where to move the element.
  The function returns the modified Array.
  function array_move_elem ( $array , $from , $to ) if ( $from == $to ) < return $array ; >
  $c = count ( $array );
  if (( $c > $from ) and ( $c > $to )) if ( $from < $to ) $f = $array [ $from ];
  for ( $i = $from ; $i < $to ; $i ++) $array [ $i ] = $array [ $i + 1 ];
  >
  $array [ $to ] = $f ;
  > else $f = $array [ $from ];
  for ( $i = $from ; $i > $to ; $i —) $array [ $i ] = $array [ $i — 1 ];
  >
  $array [ $to ] = $f ;
  >

  ?>
  Examples:
  $array = array( ‘Cero’ , ‘Uno’ , ‘Dos’ , ‘Tres’ , ‘Cuatro’ , ‘Cinco’ , ‘Seis’ , ‘Siete’ , ‘Ocho’ , ‘Nueve’ , ‘Diez’ );
  $array = array_move_elem ( $array , 3 , 5 ); // Move element in position 3 to position 5.
  print_r ( $array );

  $array = array_move_elem ( $array , 5 , 3 ); // Move element in position 5 to position 3, leaving array as it was. 😉
  print_r ( $array );

  ?>
  Return:
  Array ( [ 0 ] => Cero [ 1 ] => Uno [ 2 ] => Dos [ 3 ] => Cuatro [ 4 ] => Cinco [ 5 ] => Tres [ 6 ] => Seis [ 7 ] => Siete [ 8 ] => Ocho [ 9 ] => Nueve [ 10 ] => Diez )
  Array ( [ 0 ] => Cero [ 1 ] => Uno [ 2 ] => Dos [ 3 ] => Tres [ 4 ] => Cuatro [ 5 ] => Cinco [ 6 ] => Seis [ 7 ] => Siete [ 8 ] => Ocho [ 9 ] => Nueve [ 10 ] => Diez )
  ?>

  Updated code of ‘indioeuropeo’ with option to input string-based keys.

  FUNCTION:
  function array_move_elem ( $array , $from , $to ) // return if non-numeric couldn’t be found or from=to
  if(! is_numeric ( $from )) if( array_search ( $from , array_keys ( $array ))!== FALSE ) $from = array_search ( $from , array_keys ( $array ));
  >else return $array ;
  >
  >
  $array_numeric_keys = array();
  foreach( $array as $k => $v ) $array_numeric_keys [] = $k ;
  >
  if ( $from == $to ) < return $array ; >
  $c = count ( $array_numeric_keys );
  if (( $c > $from ) and ( $c > $to )) if ( $from < $to ) $f = $array_numeric_keys [ $from ];
  for ( $i = $from ; $i < $to ; $i ++) $array_numeric_keys [ $i ] = $array_numeric_keys [ $i + 1 ];
  >
  $array_numeric_keys [ $to ] = $f ;
  > else $f = $array_numeric_keys [ $from ];
  for ( $i = $from ; $i > $to ; $i —) $array_numeric_keys [ $i ] = $array_numeric_keys [ $i — 1 ];
  >
  $array_numeric_keys [ $to ] = $f ;
  >

  >
  $array_new = array();
  foreach( $array_numeric_keys as $v ) $array_new [ $v ] = $array [ $v ];
  >
  return $array_new ;
  >
  ?>

  Here is a function to find out the maximum depth of a multidimensional array.

  // return depth of given array
  // if Array is a string ArrayDepth() will return 0
  // usage: int ArrayDepth(array Array)

  function ArrayDepth ( $Array , $DepthCount =- 1 , $DepthArray =array()) $DepthCount ++;
  if ( is_array ( $Array ))
  foreach ( $Array as $Key => $Value )
  $DepthArray []= ArrayDepth ( $Value , $DepthCount );
  else
  return $DepthCount ;
  foreach( $DepthArray as $Value )
  $Depth = $Value > $Depth ? $Value : $Depth ;
  return $Depth ;
  >
  ?>

  While PHP has well over three-score array functions, array_rotate is strangely missing as of PHP 5.3. Searching online offered several solutions, but the ones I found have defects such as inefficiently looping through the array or ignoring keys.

  The following array_rotate() function uses array_merge and array_shift to reliably rotate an array forwards or backwards, preserving keys. If you know you can trust your $array to be an array and $shift to be between 0 and the length of your array, you can skip the function definition and use just the return expression in your code.

  function array_rotate ( $array , $shift ) if(! is_array ( $array ) || ! is_numeric ( $shift )) if(! is_array ( $array )) error_log ( __FUNCTION__ . ‘ expects first argument to be array; ‘ . gettype ( $array ). ‘ received.’ );
  if(! is_numeric ( $shift )) error_log ( __FUNCTION__ . ‘ expects second argument to be numeric; ‘ . gettype ( $shift ). » ` $shift ` received.» );
  return $array ;
  >
  $shift %= count ( $array ); //we won’t try to shift more than one array length
  if( $shift < 0 ) $shift += count ( $array ); //handle negative shifts as positive
  return array_merge ( array_slice ( $array , $shift , NULL , true ), array_slice ( $array , 0 , $shift , true ));
  >
  ?>
  A few simple tests:
  $array =array( «foo» => 1 , «bar» => 2 , «baz» => 3 , 4 , 5 );

  print_r ( array_rotate ( $array , 2 ));
  print_r ( array_rotate ( $array , — 2 ));
  print_r ( array_rotate ( $array , count ( $array )));
  print_r ( array_rotate ( $array , «4» ));
  print_r ( array_rotate ( $array , — 9 ));
  ?>

  Short function for making a recursive array copy while cloning objects on the way.

  function arrayCopy ( array $array ) $result = array();
  foreach( $array as $key => $val ) if( is_array ( $val ) ) $result [ $key ] = arrayCopy ( $val );
  > elseif ( is_object ( $val ) ) $result [ $key ] = clone $val ;
  > else $result [ $key ] = $val ;
  >
  >
  return $result ;
  >
  ?>

  /*to change an index without rewriting the whole table and leave at the same place.
  */
  function change_index (& $tableau , $old_key , $new_key ) $changed = FALSE ;
  $temp = 0 ;
  foreach ( $tableau as $key => $value ) switch ( $changed ) case FALSE :
  //creates the new key and deletes the old
  if ( $key == $old_key ) $tableau [ $new_key ] = $tableau [ $old_key ];
  unset( $tableau [ $old_key ]);
  $changed = TRUE ;
  >
  break;

  case TRUE :
  //moves following keys
  if ( $key != $new_key ) $temp = $tableau [ $key ];
  unset( $tableau [ $key ]);
  $tableau [ $key ] = $temp ;
  break;
  >
  else < $changed = FALSE ;>//stop
  >
  >
  array_values ( $tableau ); //free_memory
  >

  //Result :
  $tableau = array( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 );
  $res = print_r ( $tableau , TRUE );
  $longueur = strlen ( $res ) — 1 ;
  echo «Old array :\n» . substr ( $res , 8 , $longueur ) . «\n» ;

  change_index ( $tableau , 2 , ‘number 2’ );
  $res = print_r ( $tableau , TRUE );
  $longueur = strlen ( $res ) — 10 ;
  echo «New array :\n» . substr ( $res , 8 , $longueur ) . «\n» ;

  Источник

  PHP array_reverse() Function

  The array_reverse() function returns an array in the reverse order.

  Syntax

  Parameter Values

  Technical Details

  Return Value:	Returns the reversed array
  PHP Version:	4+
  PHP Changelog:	The preserve parameter was added in PHP 4.0.3

  More Examples

  Example

  Return the original array, the reversed array and the preserved array:

  

  COLOR PICKER

  

  

  Report Error

  If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

  Thank You For Helping Us!

  Your message has been sent to W3Schools.

  Top Tutorials

  Top References

  Top Examples

  Get Certified

  W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

  Источник

  Читайте также:  Mysql настройки подключения php