[RESOLVED] rotate continuously through associative array

NogDog

Any recommendations for a clean, efficient way to rotate through the values of an associative array. The objective is to use each element once, then start over again when it's used up (distribute the usage as evenly as possible). My first crude idea was something like this:

$data = array(
  'key' => 'value',
  'etc.' => 'et cetera'
);

$temp = $data;
while($some_loop_indicator_here) {
  if(count($temp) == 0) {
    $temp = $data;
  }
  do_something_with(array_pop($temp));
}

That should work fine, but I don't find it aesthetically pleasing. 🙂

Derokorian

$i = 0;
$array = array(
  'key' => 'value', 
  'etc.' => 'et cetera' 
);
end($array);
$strKeyLast = key($array);
reset($array);
do {
   $strKey = key($array);
   $strVal = current($array);
   printf("strKey: %s<br>strVal: %s<br>", $strKey, $strVal);//do_something_here();
   if( $strKey == $strKeyLast )
      reset($array);
   else
      next($array);
   $i++;
   if( $i > 10 )
      break;
} while( FALSE !== key($array) );

printf("%d: %s", $i, $strKeyLast);

Here's what I came up with quickly, I added a counter to prevent my test from infinitely looping

johanafm

NogDog;11036141 wrote:
That should work fine, but I don't find it aesthetically pleasing. 🙂

I still believe you have found the cleanest way of doing it…

Third possibility, although I can't say I find it more readable than your own solution

function go($arr) {
    # 10 iterations
    $stopper = 10;

# used for modulo-ing around the array
$len = count($arr);

# needed for assoc arrays
$keys = array_keys($arr);

# "infinite" looping (except for $stopper)
for ($i = 0; $stopper > 0; $stopper -= 1, $i += 1) {
    # the work
    do_stuff($arr[$keys[$i % $len]]);
}
}

NogDog

johanafm;11036147 wrote:
I still believe you have found the cleanest way of doing it…
...

In that the array will probably be at most 20 elements long, it's probably the way I'll go for now. If it could potentially reach a situation where it would be much bigger, I might look for some sort of solution that didn't require continually recopying that array, probably using next() and reset(), etc.

Derokorian

NogDog;11036149 wrote:
If it could potentially reach a situation where it would be much bigger, I might look for some sort of solution that didn't require continually recopying that array, probably using next() and reset(), etc.

That's why I used my solution. I wasn't sure the size of the array, and I hate copying an array if I can avoid it.

Note, if your array increases, if you could probably wrap the logic in an Iterator or Generator

sneakyimp

I'm confused by the discussion here and am obviously missing something. What's wrong with a foreach loop?

$data = array(
  'key' => 'value',
  'etc.' => 'et cetera'
);

foreach($data as $key => $value) {
  // do something with $key and/or $value
}

johanafm

He wants it to automatically and continously restart at the top.

But on the other hand. Wouldn't it suffice to wrap the foreach in a while ($whatever)?

$arr = [
    'one' => 1,
    'two' => 2,
    'thr' => 3
];

function go($arr) {
    # 10 iterations
    $stopper = 10;

while (true) {
    foreach ($arr as $k => $v) {
        printf('%s: %d%s',
            $k,
            $v,
            PHP_EOL
        );
        $stopper -= 1;
        if ($stopper <= 0)
            return;
    }
}
}
go($arr);

johanafm

edit: just realized I reposted derokorian's solution :queasy:

function go($arr) {
    $stopper = 10;

while ($stopper > 0) {
    list ($k, $v) = each($arr);
    workIt($k, $v);

    if (key($arr) === null) {
        reset($arr);
    }
    $stopper -= 1;
}
}
go($arr);

Weedpacket

I'll play.

while(true)
{
    foreach($data as $key=>$value)
    {
        do_something($key, $value);
    }
}

With a "test" - "break/break 2" or smarter outer loop condition as appropriate.

Derokorian

I got it:

function reiterateArray(&$array, $count, $callback)
{
	for( $i=0; $i<$count; $i++ )
		foreach( $array as $k => $v )
			$callback($k, $v);
}

NogDog

FWIW, it's basically something like this:

loop through query results
   use next available element from that array
   process a request using this query result along with that array element's data
end loop

I have a (crazy?) idea of turning it into an enumerated array, and using a $counter variable in the main loop, so that I can simply(?) access $data[$counter % count($data)].

However, based on some further information I just got today, this whole process might not fly and require some major rethinking on my part, so at this point it may be more of a hypothetical question. :rolleyes:

bradgrafelman

NogDog;11036197 wrote:
I have a (crazy?) idea of turning it into an enumerated array, and using a $counter variable in the main loop, so that I can simply(?) access $data[$counter % count($data)].

That was going to be my idea, dagnabit.

// rotate through:
$array = array("bar" => "foo", "baz" => "hello", "biz" => "world");

// while displaying your super-interesting DB results:
$results = range(1, 20);

// by doing something like:
$i = 0;
$num = count($array);
$keys = array_keys($array);
foreach($results as $result) {
    echo "Result: $result, rotating array value: "
         . $array[$keys[$i++ % $num]] . "\n";
}

sneakyimp

If the idea is to start again at the top of your query results, that might require you to use data_seek or something similar.

I'm still not exactly clear on what the tricky part is. NogDog is clearly on top of the coding thing. It's sounding like he wants to have quick and convenient access (i.e., "random access") to the data fields of a (possibly large) collection of records. For very large data sets, I would recommend simply relying on the database engine to get the one record you want when you need it. Obviously, this will be slow if you need to do a lot of data accesses within a single script's run (or in a loop or something).

If you have sufficient memory available, you could indeed create a large numerically indexed array of associative arrays where each associative array represents one of the records from your db.

NogDog

It's just a case that the results retrieved from the database (the main loop) were to then be sent to a method that requires some additional parameters not in the DB result, and which (at the time of the original post) I thought I might want to effectively "load balance" those additional parameters (from the array), so that one set of those parameters didn't end up being used more than any others (due to potential billing aspects). It's tough for me to really explain without potentially wandering into the realm of confidential information. My original solution should work fine if I in fact end up having to do that; I just felt it was sub-optimal in that it would require constantly recopying the array if I'm processing a lot of DB results at once.

Fortunately, based on recent info and hopefully clarified at a meeting tomorrow, this won't be an issue, so now it's (probably) just a brain exercise if anyone is actually motivated to exercise theirs. 🙂 I think we do have plenty of viable solutions, so I'm going to mark it resolved, but don't hesitate to respond if you have and clever (or humorous) alternatives.

Weedpacket

Because in order to call ourselves l33t coderz we have to use the latest shiny at every opportunity.

function loopthese(array $array)
{
	if(empty($array))
	{
		return;
	}

$array = array_map(function(&$item)
{
	$item = (object)['key' => $item[0], 'value' => $item[1], 'next' => null];
}, array_map(null, array_keys($array), array_values(array));

$n = count($array);
for($i = 0; $i < $n; ++$i)
{
	$array[$i]->next = $array[($i + 1) % $n];
}

$current= $array[0];
for(;;)
{
	yield $current->key => $current->value;
	$current= $current->next;
}
}


foreach(loopthese($items) as $key => $item)
{
	.....
}

NogDog

<?php

class EndlessLoop implements Iterator
{
	private $var = array();

public function __construct($array)
{
	if (is_array($array)) {
		$this->var = $array;
	}
}

public function rewind()
{
	reset($this->var);
}

public function current()
{
	return current($this->var);
}

public function key()
{
	return key($this->var);
}

// where the magic happens:
public function next()
{
	$var = current($this->var);
	next($this->var);
	if(!$this->valid()) {
		$this->rewind();
	}
	return $var;
}

public function valid()
{
	$key = key($this->var);
	return ($key !== NULL && $key !== FALSE);
}
}

$looper = new EndlessLoop(range(1,10));
for($i=1; $i<=25; $i++) {
	echo "$i: ".$looper->next()."<br />\n";
}

🆒