How can I detect a cycle when iterating array?

Question

$arr = array(
  'a'          => 1,
  'b'          => 15,
  'c'          => 0,
);

$arr['c'] = &$arr;

print_r($arr); // <-- CYCLE

Do you know how can I detect if I have array values that somehow point to the existing element, or cause a infinite loop?

Answer 1

Use memory, Luke. When your iterator comes across the array as an elementof another one, just store reference/id of it to smth like set or list (or another suitable container, eg. array). So you memorize what array you have already processed, and then ignore it when meet next time or stop the loop.

<?php
function get_id(&$array) {
  return crc32(serialize($array)); 
}

# This will not work as expected. I leave it here just for future versions.
function get_id_alt(&$array) {
  $obj = (object) $array;
  return spl_object_hash($obj);
}

function iterate(array $input, &$reached=array(), $id_func='get_id') {
  // this is an unseen array, memorize it
  array_push($reached, $id_func($input));

  foreach($input as $key=>$item) {
    if (is_array($item)) {        // This is an array
      if (in_array($id_func($item), $reached)) {
        // We found an array that have been processed before. What will you do?
      } else {
        // Recurse!
        iterate($item, $reached);
      }
    } else {
      // It is not traversable value, do what you want here
    }
  }
}

PS: I'm using spl_object_hash as a ID-function, you may use another one, if prefered (but i don't know others that can identify the same objects, as this one does).

UPD: Using spl_object_hash doesn't give right results as of PHP 5.3.10: it treats any array as the same object regardless of its content. But using smth like %hash_fn%(serialize($array)) works well (beware of performance degradation!).

Answer 2

If print_r tells you of recursions, why don't use it? :)

// Set up bad array
$arr = array(
  'a'          => 1,
  'b'          => 15,
  'c'          => 0,
);
$arr['c'] = &$arr;

// Check print_r
if(strpos(print_r($a,1),'*RECURSION*') !== false) {
  echo "Houston, we got a problem!\n";
}

Edit: As outlined by @Vyktor, this does not work in all cases and may produce false positves, but serialize() also gives an indicator for recursion. It gives R for recursion. So we check, if there is an R outside of any string in the output of serialize():

<?php
// Set up bad array
$arr = array(
  'a'          => 1,
  'b'          => 15,
  'c'          => 0,
);
$arr['c'] = &$arr;

$str = serialize($arr);   // Serialize it
$len = strlen($str);      // Get the length

// Simple serialize "parser"
$state = 0;
$recursion_found = false;
for($i=0;$i<$len;$i++) {
  $byte = $str[$i];
  if($byte == "\"" && $state == 0) {
    $state = 1; // in string!
  } else if($byte == "\"" && $state == 1) {
    // Check if the " is escaped
    if($str[$i-1] != "\\") {
      $state = 0; // not in string
    }
  } else if($byte == "R" && $state == 0) { // any R that is not in a string
    $recursion_found = true;
  }
}

if($recursion_found) {
  echo "There is recursion!\n";
}

Answer 3

(I just posted this as an answer to the Is there a way to detect circular arrays in pure PHP? question that @Cheery mentioned, but I may be updating that answer depending on that asker's needs.)

The isRecursiveArray(array) method below detects circular/recursive arrays. It keeps track of which arrays have been visited by temporarily adding an element containing a known object reference to the end of the array.

function removeLastElementIfSame(array & $array, $reference) {
    if(end($array) === $reference) {
        unset($array[key($array)]);
    }
}

function isRecursiveArrayIteration(array & $array, $reference) {
    $last_element   = end($array);
    if($reference === $last_element) {
        return true;
    }
    $array[]    = $reference;

    foreach($array as &$element) {
        if(is_array($element)) {
            if(isRecursiveArrayIteration($element, $reference)) {
                removeLastElementIfSame($array, $reference);
                return true;
            }
        }
    }

    removeLastElementIfSame($array, $reference);

    return false;
}

function isRecursiveArray(array $array) {
    $some_reference = new stdclass();
    return isRecursiveArrayIteration($array, $some_reference);
}



$array      = array('a','b','c');
var_dump(isRecursiveArray($array));
print_r($array);



$array      = array('a','b','c');
$array[]    = $array;
var_dump(isRecursiveArray($array));
print_r($array);



$array      = array('a','b','c');
$array[]    = &$array;
var_dump(isRecursiveArray($array));
print_r($array);



$array      = array('a','b','c');
$array[]    = &$array;
$array      = array($array);
var_dump(isRecursiveArray($array));
print_r($array);

Answer 4

Derivative work for arrays and objects (both):

function isRecursiveArrayObjectTest(&$object, $marker)
{
    if ( is_array($object) ) {
        // Move the array pointer to the end and test if we encounter the marker (if so, its recursive)
        $last = end($object);
        if ($marker === $last) {
            return true;
        }
        // Add a marker to the end of the array to test for recursion (removed upon exit)
        $object[] = $marker;
    } elseif ( is_object($object) ) {
        // Treat objects differently
        if ( $marker === $object->__testRecursion ) {
            return true;
        }
        // Add a marker using a member that is unlikely to be defined (removed upon exit)
        $object->__testRecursion = $marker;
    } else {
        return false;
    }

    $isRecur = false;

    // Loop over the elements of the array, recursively testing each one (if it is an array|object)
    foreach($object as &$element) {
        if(is_array($element) || (is_object($element) && $element !== $marker)) {
            if(isRecursiveArrayObjectTest($element, $marker)) {
                $isRecur = true;
                break;
            }
        }
    }

    // remove marker before we leave
    if (is_array($object) && end($object) === $marker) {
        unset($object[key($object)]);
    } elseif ( is_object($object) && isset($object->__testRecursion) ) {
        unset($object->__testRecursion);
    }

    return $isRecur;
}

function isRecursiveArrayObject($object)
{
    // Create a 'marker' to detect where we have visited to determine recursion
    $marker = new stdClass();
    return isRecursiveArrayObjectTest($object, $marker);
}