Iterate a PHP array from a specific key

Try combining array_search, array_key, and LimitIterator. Using the example from the LimitIterator page and some extra bits:

$fruitsArray = array(
    'a' => 'apple',
    'b' => 'banana',
    'c' => 'cherry',
    'd' => 'damson',
    'e' => 'elderberry'
);

$startkey = array_search('d', array_keys($fruitsArray));

$fruits = new ArrayIterator($fruitsArray);

foreach (new LimitIterator($fruits, $startkey) as $fruit) {
    var_dump($fruit);
}

Starting at position 'd', this outputs:

string(6) "damson" string(10) "elderberry"

There is a limit to this approach in that it won’t loop around the array until the start position again. It will only iterate to the end of an array and then stop. You would have to run another foreach to do the first part of the array, but that can be easily done with the code we already have.

foreach (new LimitIterator($fruits, 0, $startkey-1) as $fruit) {
    var_dump($fruit);
}

This starts from the first element, up to the element before the one we searched for.

foreach always resets the array's array pointer. You just can't do that the way you imagine.

You still have a few ways. The foreach way is just skipping everything until you found the key once:

$start_key = "yy";
$started = false;
foreach ($my_array as $key => $v)
{
    if ($key == $start_key) {
        $started = true;
    }
    if (!$started) {
        continue;
    }
    // your code
}

You could as well work with the array pointer and use the while (list($key, $v) = each($array)) method:

$start_key = "yy";
reset($array); // reset it to be sure to start at the beginning
while (list($key, $v) = each($array) && $key != $start_key); // set array pointer to $start_key
do {
    // your code
} while (list($key, $v) = each($array));

Alternatively, you can just extract the array you want to iterate over like MarkBaker proposed.

Perhaps something like:

foreach(array_slice(
    $my_array,
    array_search(
        $start_key,array_keys($my_array)
    ),
    null,
    true) as $key => $v) {}

Demo

You can use array_keys and array_search.

Like this:

$keys = array_keys( $my_array ); // store all of your array indexes in a new array
$position = array_search( "yy" ,$keys ); // search your starting index in the newly created array of indexes
if( $position == false ) exit( "Index doesn't exist" ); // if the starting index doesn't exist the array_search returns false

for( $i = $position; $i < count( $keys ); $i++  ) { // starting from your desired index, this will iterate over the rest of your array
    // do your stuff to $my_array[ $keys[ $i ] ] like:
    echo $my_array[ $keys[ $i ] ];
}

Try it like this:

$startkey = array_search('yy', array_keys($my_array));
$endkey = array_search('zz', array_keys($my_array));

$my_array2 = array_values($my_array);

for($i = $startkey; $i<=$endkey; $i++)
{
    // Access array like this
    echo $my_array2[$i];
}

If this pull request makes it through, you will be able to do this quite easily:

if (seek($array, 'yy', SEEK_KEY)) {
    while ($data = each($array)) {
        // Do stuff
    }
}

If you create the array once and then use it many times, you can index the array keys and that would be more efficient and clean than iterating all the elements every time. See this class as an example:

<?php


class IndexedArrayIterator implements Iterator {
    
    protected $data=array();
    protected $keyIndex=array();
    protected $reverseIndex=array();
    protected $position=0;
    protected $startIndex=0;
    protected $endIndex=0;
    
    function __construct($source) {
        $this->data=$source;
        $this->reindex();
    }
    
    function reindex() {
        // Reindexing is expensive, don't do it often
        // If you need to reindex every time you search, you loose the advantage
        // If you add elements, you must reindex
        $this->keyIndex = array_keys($this->data);
        $this->reverseIndex = array_flip($this->keyIndex);
    }
    
    function setStartKey($start) {
        $this->startIndex=$this->reverseIndex[$start];
    }
    
    function setEndKey($end) {
        $this->endIndex=$this->reverseIndex[$end];
    }
    

    /////
    ///      Iterator Interface
    //

    #[\ReturnTypeWillChange]
    public function rewind() {
        $this->position=$this->startIndex;
    }

    #[\ReturnTypeWillChange]
    public function current() {
        if($this->valid()) return $this->data[$this->key()];
        else return NULL;
    }

    #[\ReturnTypeWillChange]
    public function key() {
        if($this->valid()) return $this->keyIndex[$this->position];
        else return NULL;
    }

    #[\ReturnTypeWillChange]
    public function next() {
        ++$this->position;
    }

    #[\ReturnTypeWillChange]
    public function valid() {
        if($this->position > $this->endIndex) return FALSE;
        return isset($this->keyIndex[$this->position]);
    }
    
}

Usage example:

$iterator=new IndexedArrayIterator([
    'one'=>'Item One',
    'two'=>'Item Two',
    'twoandhalf'=>'Item Two And Half',
    'three'=>'Item Three',
    'four'=>'Item Four',
]);

$iterator->setStartKey('two');
$iterator->setEndKey('three');

foreach($iterator as $key=>$value) {
    echo($key.': '.$value."\r\n");
}

Working code:

https://3v4l.org/EP0fL