recursivamente - ¿Iterar a la inversa a través de una matriz con PHP-SPL?

recorrer array recursivamente php

Question

¿Hay un iterador de matriz inversa SPL en PHP? Y si no, ¿cuál sería la mejor manera de lograrlo?

Simplemente podría hacer

$array = array_reverse($array);
foreach($array as $currentElement) {}

o

for($i = count($array) - 1; $i >= 0; $i--)
{

}

¿Pero hay una forma más elegante?

Answer 1

$ array1 = array (10,20,30,40,50);

        for($i = count($array1) - 1; $i >= 0; $i--)
        {
            $array2[]  = $array1[$i];

        }

        echo "<pre>";
            print_r($array2);
        echo "</pre>";

Answer 2

Aquí hay una solución que no copia y no modifica la matriz:

for (end($array); key($array)!==null; prev($array)){
  $currentElement = current($array);
  // ...
}

Si también desea una referencia a la clave actual:

for (end($array); ($currentKey=key($array))!==null; prev($array)){
  $currentElement = current($array);
  // ...
}

Esto funciona siempre ya que las claves de matriz php nunca pueden ser nulas y son más rápidas que cualquier otra respuesta dada aquí.

Answer 3

Basado en la respuesta de linepogl ... Puede hacerlo aún más eficiente al evitar current() llamadas current()

for ($value = end($array); ($key = key($array)) !== null; $value = prev($array)) {
     // ... do something with $key => $value
}

Answer 4

Basado en la respuesta de linepogl , se me ocurrió esta función:

/**
 * Iterate an array or other foreach-able without making a copy of it.
 *
 * @param array|/Traversable $iterable
 * @return Generator
 */
function iter_reverse($iterable) {
    for (end($iterable); ($key=key($iterable))!==null; prev($iterable)){
        yield $key => current($iterable);
    }
}

Uso:

foreach(iter_reverse($my_array) as $key => $value) {
    // ... do things ...
}

Esto funciona en arreglos y otros iterables sin hacer primero una copia del mismo.

Answer 5

Dependiendo de lo que esté intentando hacer, es posible que desee ver las clases de estructura de datos de spl, como SplStack. SplStack implementa Iterator, ArrayAccess y Countable, por lo que en su mayoría se puede usar como una matriz, pero de manera predeterminada, su iterador procede en el orden de FILO. Ex:

$stack = new SplStack();
$stack[] = ''one'';
$stack[] = ''two'';
$stack[] = ''three'';

foreach ($stack as $item)
{
    print "$item/n";
}

Esto imprimirá

three
two
one

Answer 6

Esto podría ser una forma más eficaz ya que no construye una nueva matriz. También maneja bien las matrices vacías.

$item = end($items);
while($item)
{
    ...do stuff...
    $item = prev($items);
}

Answer 7

No hay ReverseArrayIterator para hacer eso. Tu puedes hacer

$reverted = new ArrayIterator(array_reverse($data));

o convertirlo en su propio iterador personalizado, por ejemplo,

class ReverseArrayIterator extends ArrayIterator 
{
    public function __construct(array $array)
    {
        parent::__construct(array_reverse($array));
    }
}

Answer 8

Tenga en cuenta que si desea conservar las claves de la matriz, debe pasar true como segundo parámetro a array_reverse :

$array = array_reverse($array, true);
foreach ($array as $currentElement) {
    // do something here
}

Answer 9

$array = array_reverse($array);
foreach($array as $key => $currentElement) {}

Esta es la mejor manera de usar. También se encargará de las claves, si no son secuenciales o enteras.

Answer 10

$array=array(
    0 => 0,
    ''1'' => 1,
    2 => null,
    3 => false
);

$value=end( $array );                      // ← value for first iteration
while(($key=key( $array )) !== null) {
  echo "key=$key, value=$value/n";

  $value=prev( $array );                   // ← value for next iteration
}

Answer 11

$item=end($array);
do {
...
} while ($item=prev($array));