Funzione ricorsiva: chiama la funzione php stessa

Question

Voglio solo assicurarmi di farlo bene e questo non creerà alcun conflitto.

Ho una funzione che chiama se stessa e richiede la tua approvazione se è OK o non farlo?

<?php 

function determine($the_array){ 
    foreach ($the_array as $key => $value) { 
     switch ($key) { 
      case 'in': 
        echo $value; 
       break; 

      case 'out': 
        echo $value; 
       break; 

      case 'level': 
        echo '<ul>'; 
        determine($value); 
        echo '</ul>'; 
       break; 

     } 
    } 

} 

Questa è la matrice:

$the_array = array(
    'in' => '<li>Simple IN</li>', 
    'out' => '<li>Simple OUT</li>', 
    'level' => array(
      'in' => '<li>Simple IN 2</li>', 
      'out' => '<li>Simple OUT 2</li>', 
      'level' => array(
       'in' => '<li>Simple IN 3</li>', 
       'out' => '<li>Simple OUT 3</li>' 
      ), 
     ), 
); 

E qui è l'init finale:

echo '<ul>'; 
determine($the_array); 
echo '</ul>'; 

Il risultato è proprio come avrei voluto essere, funziona benissimo, ma io don so se questa è una buona pratica

Answer 1

Le funzioni ricorsive sono OK, ma pericolose se non si è sicuri di sapere cosa si sta facendo. Se esiste la possibilità che una funzione finisca in un ciclo ricorsivo (dove continua a chiamarsi ripetutamente), si esaurirà il tempo, esaurirà la memoria o causerà un'apocalisse zombi.

Pensate alle chiamate ricorsive come a un coltello davvero molto affilato: nelle mani di uno chef esperto, è un incontro fatto in paradiso, nelle mani della lavastoviglie, è un dito perso che aspetta di accadere.

PHP cerca di suonare bello, e limita una profondità ricorsiva a 100 di default (anche se questo può essere modificato) ma per quasi tutti i casi, se la profondità ricorsiva arriva a 100, l'incidente è già successo e PHP reagisce fermandosi eventuali pedoni aggiuntivi da vagare nel traffico. :)

Answer 2

Fluffeh ha fornito una risposta sufficiente per quanto riguarda le funzioni ricorsive. Ma quando si usa la ricorsione con grandi matrici/oggetti/etc, si dovrebbe osservare l'ottimizzazione del proprio codice, in modo che non ci sia bisogno di molta memoria o potenza della CPU da eseguire.

Si potrebbe facilmente ottimizzare il codice per essere più pulito, prendere meno memoria ed essere più resistente ai dati imprevisti. Notare & nell'elenco di argomenti della funzione (elimina la creazione di una copia di un array ogni volta che viene chiamata una funzione nidificata).

function determine(& $the_array){ 
foreach ($the_array as $key => $value) { 
    switch ($key) { 
     case 'in': 
     case 'out': 
       echo $value; 
      break; 

     case 'level': 
      if (!is_array($value)) break; 
       echo '<ul>'; 
       determine($value); 
       echo '</ul>'; 
      break; 

     } 
    } 
} 

Answer 3

Penso che se si conosce la profondità di gamma è bene usare

$list = ""; 
foreach ($the_array as $array) { 
    if(is_array($array)) { 
     foreach($array as $sub_array) { 
      if(is_array($sub_array)) { 
       foreach($sub_array as $sub_array_2) { 
        $list .= "$sub_array_2"; 
       } 
      } else { 
      $list .= "$sub_array"; 
      } 
     } 
    } else { 
     $list .= "$array"; 
    } 
} 

echo "<ul>$list</ul>"; 

Answer 4

Non so, se si tratta di una buona soluzione, ma io uso questo per chiamare una funzione dall'interno stesso:

function my_calucar(){ 
    $arrayy= array('mine' => '1', 'yours' => '24', 'her' => '34'); 
    foreach ($arrayy as $each=>$value) { 
     switch ($each) { 
     default: 
       my_calucar($value); 
     } 
    } 
}