PHP OO Salir de funcion recursiva

[bgva2005]

Estimados todos, tengo la siguiente función recursiva:

function recorro($matriz, $directorioPadre)
{

foreach ($matriz as $key => $value) {

if (is_object($value)) {
$nombre = $value->getNombre();
if ($nombre == $directorioPadre) {
$encontro = TRUE;
$a['encontro'] = $encontro;
$a['tipoElemento'] = $value->getTipoElemento();
$a['key'] = $key;
$a['arreglo'] = $value;
$continuar = FALSE;
return $a; //retorna el objeto
} else {
$tipoObjeto = get_class($value);
if ($tipoObjeto == 'Directorio') {
//tiene subdirectorios
$listaElementos = $value->getListaElementos();
$numElementos = count($listaElementos);
if ($numElementos > 0) {
//si tiene elementos lo debe recorrer
$this->recorro($listaElementos, $directorioPadre);
}
}
}
} elseif (is_array($value)) {
//si es un array sigo recorriendo
recorro($value);
} else {
//si es un elemento lo muestro
$a = 'key:' . $value;
echo $a;
echo '<br>';
}
}

}

la idea de esta funcion es que recorra un array compuesto de objetos y me retorne el que coincida con cierto nombre, pero el problema es que llega a un nivel en que encuentra el nombre pero por la recursividad se sigue ejecutando, no se como resolverlo. Es decir deseo que una vez que haga el "return $a" se salga y no ejecute más.

[JairLizcano]

Es evidente que la función recursiva debe finalizar al retornar la variable $a, ahora mi pregunta es si la condición bajo los parámetros que indicas se cumple.

¿Has probado con valores que satisfagan la condición?

Buena suerte.

[Triby]

El uso de una variable estática podría servir.

[rigobcastro]

Bueno, yo comprobaria primero el tipo de variable luego ejecuto el bucle, tambien si necesito recorrer un objeto, me aseguro de que asi sea.

Haria algo así pero pues como dice JairLizcano necesitas saber que valores son y claro, el resto de codigo para ver si se puede simplificar..

Código PHP:

function recorro($matriz, $directorioPadre) {
 
    // Comprobamos si es una matriz u objecto para ejecutar el bucle de recorrido, si no imprime
    if (is_object($matriz) OR is_array($matriz)) {
        // Aseguramos de que la matriz se convierta a objeto
        $matriz = (object) $matriz;
        
        // Recorremos con la seguridad de que es un objecto lo que vamos a recorrer     
        foreach ($matriz as $key => $value) {
            $nombre = $value->getNombre();
            if ($nombre == $directorioPadre) {
                $encontro = TRUE;
                $a['encontro'] = $encontro;
                $a['tipoElemento'] = $value->getTipoElemento();
                $a['key'] = $key;
                $a['arreglo'] = $value;
                $continuar = FALSE;
                return $a; //retorna el objeto
            } else {
                $tipoObjeto = get_class($value);
                if ($tipoObjeto == 'Directorio') {
                    //tiene subdirectorios
                    $listaElementos = $value->getListaElementos();
                    $numElementos = count($listaElementos);
                    if ($numElementos > 0) {
                        //si tiene elementos lo debe recorrer
                        $this->recorro($listaElementos, $directorioPadre);
                    }
                }
            }
        }
    } else {
        $a = 'key:' . $value;
        echo $a;
        echo '<br>';
    }
}
 

!Claro! es solo como yo lo haria en cuestion a estructura, desconocemos su funcionalidad.

Saludos...

[JairLizcano]

Me gustaría que revisarás esta clase, es de mi autoría, así te haces otras ideas de recursividad:

Código PHP:

  <?php 
    class Recursivity { 
 
        const BASIC = 0; 
        const POW = 1; 
 
        private $base; 
        private $limit; 
 
        private $serie; 
 
        public function __construct() { 
 
            $this->base = NULL; 
 
            $this->limit = NULL; 
 
            $this->serie = new ArrayObject(); 
        } 
 
        public function toFibonacci($integer) { 
 
            $result = $integer + $this->base; 
 
            if($result > $this->limit) { 
 
                return $this->serie; 
            } else { 
 
                $this->setBase($integer); 
 
                $this->serie->append($result); 
 
                return ($this->toFibonacci($result)) ? $this->serie : FALSE; 
            } 
        } 
 
        public function toPlus($integer, $mode = self::BASIC, $level = NULL) { 
 
            $result = $integer; 
 
            if($mode == self::BASIC) { 
 
                if($result >= $this->limit) { 
 
                    return $this->serie; 
                } else { 
 
                    $this->serie->append($result); 
 
                    return ($this->toPlus($result + 1)) ? $this->serie : FALSE; 
                } 
 
            } elseif ($mode == self::POW) { 
 
                if(!(empty($level))) { 
 
                    if(pow($result, $level) >= $this->limit) { 
 
                        return $this->serie; 
                    } else { 
 
                        $this->serie->append(pow($result, $level)); 
 
                        return ($this->toPlus($result + 1, self::POW, $level)) ? $this->serie : FALSE; 
                    } 
                } 
            } 
        } 
 
        public function getBase() { 
 
            return $this->base; 
        } 
 
        public function setBase($base) { 
 
            $this->base = $base; 
 
            return $this; 
        } 
 
        public function getLimit() { 
 
            return $this->limit; 
        } 
 
        public function setLimit($limit) { 
 
            $this->limit = $limit; 
 
            return $this; 
        } 
    } 
?>   

Más que todo la función toFibonacci() (al igual que toPlus(), pero es más legible toFibonacci()):

Código PHP:

   public function toFibonacci($integer) {  
 
            $result = $integer + $this->base;  
 
            if($result > $this->limit) {  
 
                return $this->serie; // Finaliza la serie de Fibonacci retornando el vector con dichos valores  
            } else {  
 
                $this->setBase($integer);  
 
                $this->serie->append($result);  
 
                return ($this->toFibonacci($result)) ? $this->serie : FALSE;  // Retorno recursivo 
            }  
        }  
   

Fue un ejercicio algo a falta de tiempo en clase, así que si necesitas documentación con respecto a ella, sólo me dices. Si te interesa.

Buena suerte.