Newsgroup: it.comp.www.php
Titolo: Tutti i file di un sito in un array

Salve,
ho la necessità di mettere tutti i file e le directory di un sito in un
array ordinato
faccio cosi
function get_site_files() {
$dirs = array();
$files = array();
$handle = opendir('.');
while (($file = readdir($handle)) !== false) {
    if(('..' !== $file) && ('.' !== $file)) {
        if (is_dir($file)) {
        $dirs[] = realpath($file);
        } else {
        $files[] = realpath($file);
        }
    }
}
closedir($handle);
return array(sort($dirs), sort($files));
}
be questo è abbastanza semplice...
vorrei tuttavia che ogni volta che lo script incontra una directory
continuasse a popolare l'array $files con i file contenuti nella directory,
nelle sottodirectory...
ovvero ogni volta che
if(is_dir($file)) da true
faccia un chdir(realpath($file) e
riapplicasse la funzione get_all_files()
fino a quando non ci sono piu directory
well i give up!
sono diventato un po pigro ultimamente
Grazie per qualsiasi suggerimento
Saluti
Corrado Modica
www.pachinoglobale.com

 Saluti
Fammi sapere

 Questa è la teoria lascio a te la pratica e il divertimento
ciao, ho risolto semplicemente richiamando la funzione all'interno di se
stessa
era piu facile di quando credevo.
e visto che la mia pigrizia è sparita
posto la funzione magari puo servire o comunqe essere migliorata
 error_reporting(E_ALL);
 function get_files() {
 $dirs = array();
 $files = array();
 $handle = opendir('.');
 while (($file = readdir($handle)) !== false) {
 if(('..' !== $file) && ('.' !== $file)) {
  if (is_dir($file)) {
  $dirs[] = realpath($file);
  } else {
  $files[] = realpath($file);
  }
 }
 }
 closedir($handle);
 foreach($dirs as $d) {
 chdir($d);
 $all  = get_files();
 if(count($all[0])>0) {
 for($i=0; $i<sizeof($all[0]); $i++) {
 $dirs[] = $all[0][$i];
 }
 }
 if(count($all[1])>0) {
 for($z=0; $z<sizeof($all[1]); $z++) {
 $files[] = $all[1][$z];
 }
 }
 }
 return array($dirs, $files);
 }
/* function in action */
 $tutti = get_files();
 while(list($k, $v) = each($tutti[1])) {
 echo $k.'-->'.$v.'<br>'."\n";
 }
Saluti
Corrado Modica
www.pachinoglobale.com

  closedir($handle);
In questo modo scendi in tutte le directory e non solo nella prima,
oltre a  essere piu` semplice la funzione.
Bye.

 ha scritto nel messaggio
news:pan.2003.02.15....@neko.it...

salve
guarda che ho provato la funzione che hai ricorretto
cosi come l'hai postata
ma cosi metti solo i file di "una cartella" in un array
a me serviva mettere tutti i file di un sito comprese le sottocartelle
e la funzione che avevo postato lo faceva egregiamente
correggimi se sbaglio
saluti
Corrado Modica
www.pachinoglobale.com

 la funzione che avevo postato lo faceva egregiamente
Non ho provato nemmeno la funzione che avevi postato tu, solo
interpretata a mente, ma mi pareva che facesse lo scan solo del primo
livello di sotto-directory, e non dei successivi, e questa cosa puo`
essere risolta (senza troppe complicazioni) solo con una funzione
ricorsiva.
Bye.

 e la compattezza del codice,
questo sì :))
Ciao

 poi mi sai dire qual è la più comprensibile
Vabbè, grazie. Intendevo dire che la ricorsione favorisce la 
comprensibilitè del codice per gli algoritmi che trovano la loro 
naturale espressione in termini ricorsivi. Altrimenti, perchè ipotizzare 
l'uso della ricorsione in primo luogo ? non mi verrebbe nemmeno in mente.


 vado avanti ?
Sě, vado avanti.
... e quando il tuo bel codice lo compili, che cosa succede ?
Diventa codice macchina. Il codice macchina che fa ?
Itera - e costruisce uno stack per "memorizzare" i contesti diversi.
Cosa ti impedisce di fare questo ad alto livello ?


 impedisce di fare questo ad alto livello ? ciao
Dipende dall'assembly.
Niente vieta di fare funzioni (o meglio subroutine) ricorsive in ASM. Lo
stack e` appunto lo scope della funzione.
Bye.

 stack e` appunto lo scope della funzione.
Forse stiamo dicendo la stessa cosa in modo diverso. Non sono certo un 
esperto di ASM, ma...
Ciò che volevo dire è che la ricorsione può sempre essere "risolta", 
"srotolata" in modo iterativo. Ciò che avviene a livello macchina 
(oddio... macchine CISC non le ho mai studiate) alla fine mi pare sia 
sempre in ultima analisi iterazione, PIU' la gestione di uno stack per 
gestire i livelli di chiamata memorizzando i contesti diversi. Se un 
segmento di ASM richiama se stesso lo fa tramite jump, il che non è 
molto diverso da un contesto iterativo.
Non vorrei dilungarmi sull'ASM perchè non ne so abbastanza, 
semplicemente intendevo dire che se hai una procedura ricorsiva, puoi 
sempre "iterativizzarla" implementando uno stack direttamente nel 
linguaggio ad alto livello. Non mi pare abbia senso farlo, ma SI PUO' FARE.
@le addirittura ha affermato che è _necessario_ usare la ricorsione per 
esamninare un albero di sottocartelle. Questo è falso nel modo più 
totale. Così su due piedi, direi che te la puoi cavare anche 
iterativamente usando cicli con pre-condizioni.
tutto qui, cmq grazie per la precisazione


 FARE.
Sicuramente. A volte e` anche piu` efficiente prestazionalmente perche`
le chiamate di  funzioni e procedure sono una delle cose piu` costose da
fare.
Il problema e` proprio la leggibilita` del codice.
Bye.

linguaggio ad alto livello. Non mi pare abbia senso farlo, ma SI PUO' FARE.
Certo, si puo' fare sempre. In alcuni casi e' anche conveniente, se la
ricorsione puo' dare origine a "raddoppiamenti" o circoli viziosi, dal
momento che prima di inserire il nuovo elemento (=istanza di chiamata)
in stack, si verifica che non vi sia gia'. Una sorta di INSERT UNIQUE.
E infatti e' possibile implementare uno stack usando un database. Solo
c'e' una piccola complicazione circa la condizione terminale - ma, per
quello, si usano due stack, o due tabelle, o un flag 0/1.
Leonardo
-- 
Time's angles, mages tell, conceal a place
incredible, beyond the mundane mind;
night-shrouded and between the seas of space
dread creatures drift in the ageless winds.