Newsgroup: it.comp.www.php
Titolo: Aiuto: come creare cicli a più livelli???

Un saluto a tutti.
Ho un GROSSO problema:
ho dei dati (che estraggo da un database) da organizzare in un elenco
a più livelli (tipo l'indice di un libro) dove ci sia:
LIVELLO 1 
	LIVELLO 2
		LIVELLO 3
Naturalmente, un livello "1" contiene 1 o più livelli "2", che a loro
volta contengono 1 o più livelli "3".
Per ora ho provato con while...ma non riesco a far niente. Non so se i
cicli con while possono essere "annidati" e -nel caso lo possano
essere- dove trovare qualche esempio da studiare e copiare.
Per favore, aiutatemi!!! 8-P
 --
Per rispondere, togliere "ITA" al dominio
 --

 |
| Delete WORLD to reply        |
|                              |
| Software is like sex...      |
| It's better when it's free.  |
+------------------------------+

 essere- dove trovare qualche esempio da studiare e copiare.
prova questi:
$i=0;
while ($i<10) {
  $j=0;
  while ($j<10) {
    $k=0;
    while ($k<10) {
      echo "$i.$j.$k <BR>\n";
      $k++;
    }
    $j++;
  }
  $i++;
}
for ($i=0; $i < 10; $i++) {
  for ($j=0; $j < 10; $j++) {
    for ($k=0; $k < 10; $k++) {
      echo "$i.$j.$k <BR>\n";
    }
  }
}
genera una lista tipo:
0.0.0
0.0.1
[...]
0.1.0
0.1.1
ecc.
for ($i=0; $i < 10; $i++) {
  echo "<h1>$i</h1> <BR>\n";
  for ($j=0; $j < 10; $j++) {
    echo "<h2>$i.$j</h2> <BR>\n";
    for ($k=0; $k < 10; $k++) {
      echo "<h3>$i.$j.$k</h3> <BR>\n";
    }
  }
}

Marco
Grazie per le risposte, ma forse non mi sono spiegato bene:
i "sottolivelli" dipendono dai livelli superiori, e quindi dovrei
"legarli" ai sottolivelli, in modo che -al variare del numero dei
livelli superiori- anche i "sottolivelli" si comportano di
conseguenza.
Ho poi bisogno che i sottolivelli siano già "inquadrati" dai livelli
superiori, ovvero non vengano estratti da un livello superiore diverso
da quello impostato come "testa di serie". 
Spero di essere stato chiaro, anche se mi accorgo che oramai faccio
fatica a ragionare, dopo 'sto scontro con il database e php.
Riporto un esempio di fantasia ma che si aggancia al mio problema: 
nel database ho questi campi:
id_gruppo: 1
ds_gruppo: cavalli da corsa
id_sezione: 1
ds_sezione: cavalli europei
id_razza: 010
ds_razza: baio...
Naturalmente ho 10 id_gruppo con altrettante ds_gruppo (descrizione
gruppo);
ogni id_gruppo[ds_gruppo] è il livello superiore di "x" sottolivelli
costituiti da id_sezione e ds_sezione, che a loro volta contengono "y"
sottolivelli costituiti da id_razza e ds_razza...
Vorrei creare un ciclo che mi gestisca (se possibile) tutti e 10 i
gruppi con le relative sezioni e razze....
Spero sia possibile...


 ha scritto nel messaggio
news:3ce11863...@news.cs.interbusiness.it...
| i "sottolivelli" dipendono dai livelli superiori, e quindi dovrei
| "legarli" ai sottolivelli, in modo che -al variare del numero dei
| livelli superiori- anche i "sottolivelli" si comportano di
| conseguenza.
ad occhio non vedo che difficolta' ci sia...
se ho capito bene il pratica sarebbe:
- per ogni id_Gruppo recupera tutto quello
  che sta nella tabella correlata
- per ogni record risultante operara un ciclo
  e fa un'altro select su un'altra tabella
- ecc... ecc...
ho capito bene?
tab_1
    id 1
    id 2
    id 3
    id 4
tab_2
    id_a 1 -- id 1
    id_a 2 -- id 1
    id_a 3 -- id 1
    id_a 3 -- id 2
    id_a 4 -- id 3
    id_a 5 -- id 4
    id_a 6 -- id 3
tab_3
    id_b 1 -- id_a 1
    id_b 2 -- id_a 3
    id_b 3 -- id_a 2
    id_b 4 -- id_a 2
    id_b 5 -- id_a 4
right? o proprio non ci ho preso?
--
[ Penguin At Work ]
-> 
http://web.tiscali.it/penguinatwork/
-> aka Fustino Di Dixan while working


 --


gruppi con le relative sezioni e razze....
Forse questo puo' esserti utile, prende 2 livelli di categorie
(e sottocategorie).
function get_categ_tree()
{
	$sql = "select id,nome from categorie where id_padre=0";
	$res = db_query($sql);
	$tree = array();
	while($r = db_fetch_array($res))
	{
		$nome 	= $r['nome'];
		$id  	= $r['id'];
		$sql2 = "select nome from categorie where 
id_padre = $id";
		$r2 = db_query($sql2);
		$tree[$nome] = array();
		while($row = db_fetch_array($r2))
		{
			$tree[$nome][] = $row['nome'];
		}
	}
	return $tree;
}
Bonf

Sulla tabella del tuo db, come sono legati i livelli?
Esiste, per un
record 'di livello2' qualcosa che ti ti dica chi è il padre? Una cosa del
genere...imvento un tracciato record al volo:
| LIVELLO | LIVELLO_RIF |
DESCRIZIONE |
|-----------------------------------------------|
| 1
|                    | Ricette romane|
|-----------------------------------------------|
|              | 1
| Carbonara      |
|-----------------------------------------------|
| 2
|                    | Vini                |
|-----------------------------------------------|
|              | 1
| Paiata             |
|-----------------------------------------------|
|              | 2                 | Castelli           |
|-----------------------------------------------|
Se hai una staruttura
del genere, allora risolvi tutto via query così i dati che ti arrivano dal
db, sono già ordinati e il tuo codice si ridurrebbe ad un paio di cicli.
Maggiori info sulla struttura della tabbela please :)
Saluti...
--------------------------------
Inviato via 
http://usenet.iol.it
 

}
..<snip>...
Grazie Bonf.
Purtroppo, per il mio livello, la tua soluzione è troppo avanzata. La
dovrò studiare con calma.


Saluti...


Non so e..... vi avverto potrei scrivere una cosa orribile ma ci provo!
(anche perchè mi era già successo di cimentarmi in una cosa del genere)
Allor....
Per quello che sto per scrivere mi serve che il db sia strutturato in modo
da avere almeno una flag che mi determini le parentele tra i campi, e un
campo che mi dica chi è il padre.
$query = "SELECT * FROM tabella WHERE flag='1'";
$result = mysql_query ($query,$open)
        or die ("vai a capì che è andato storto adesso:".mysql_error());
$padri = array();
while ($row = mysql_fetch_array($result))
        array_push($padri,$row);
/* Comincio a costruire il primo livello */
foreach ($padri as $padroni) /*Chiedo il secondo livello*/
{
        $query = "SELECT * FROM tabella WHERE padre = '$padroni[id]' AND
flag = '2'";
        $result = mysql_query($query,$open)
                    or die ("E te pareva!:".mysql_error());
         /* Gli faccio fare quello che deve fare e poi mi costruisco il
terzo livello*/
        foreach ($figli as $figliocci)
        {
                    $query = "SELECT * FROM tabella WHERE padre =
'$padroni[id]' AND figli = '$figliocci[id]' AND flag = '3'";
                    $result = mysql_query($result,$open)
                                    or die ("Io ci
rinuncio:".mysql_error());
                    /* Gli faccio fare quello che deve fare e poi mi
costruisco l'eventuale 4 livello */
/* mo me tocca chiudere tutte le graffe arf arf arf */
Cmq apparte le cazzate non mi sembra un modo molto elegante di scrivere, in
pratica è una query ogni livello.... arf arf che fatica, ma non me ne
vengono altre in mente.
Un altro modo... che non mi sembra il caso di postare alle 2 di notte
potrebbe essere quello di fare una grossa query che prende tutti i campi e
dopo fare cicli del genere
while ($record[padre])
{
        foreach ($record[figlio][1] as $figldiput)
        {
                    foreach ($figldput[figlio][1] as $lupmannar)
        }
Insomma, apparte che quel giochetto con i foreach un se po' fa! (intendo
passare un array in quel modo) ci dovrebbe essere un sistema per lavorare
solo di array.
Spè spè si potrebbe fare ordinando gli array per key..... si ma che key? e
le parentele?
Bo insomma che ne so così come ho scritto il primo funzia in altro modo ci
devo pensare domani mattina.





Porco schifo perdonatemi chiedo umilmente scusa a tutti!!!