Discussion :

[Sof34]

Bonjour a tous,

J'ai encore un petit souci qui de tri avec lequel je n'arrive pas à m'en sortir. Voila pourquoi je m'en m'enrichir des lumières de Développez.com :


J'ai une table (très grosse) contenant des chaines constituées comme suit :

A
A - a
A - a - b
A - a - c

B - a
B - a - b
B - a - b - c

etc..

mon objectif est d'exploser tout ca dans les tables distincts sous la forme

Table catégories :

id valeur

Table sous catégorie :

id valeur id_catégorie

Table sous sous catégorie :

Id Valeur id_catégorie id_sous_catégorie

etc...



Avec ce qui suit j'arrive à créer un tableau pour y voir plus clair avant de faire mes insertions, mais je bloque au niveau de la comparaison de la valeur précédente...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<table width="100%" border="1">
<?php do { 
 
$result = htmlentities($row_selectCat['categorie']);
 
$result = str_replace("  ", "", $result);
 
$array_cat = explode(" - ", $result);
 
?>
  <tr>
	<?php for ($i = 1; $i < count($array_cat); $i++) { 
 
    if ($array_cat[$i] != $array_cat[$i-1]) { ?>
 
        <td><?php echo $array_cat[$i]; ?></td>
 
    <?php } else { echo $array_cat[$i]; } ?>
  </tr>
  <?php }} while ($row_selectCat = mysql_fetch_assoc($selectCat)); ?>
</table>

J'ai essayé avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<?php if (in_array($row_selectCat['id'],$array_cat)) { echo $array_cat[$i];}?>

Mais je n'arrive pas a un résultat concluant...

Merci par avance de votre aide.

[gene69]

oui tu peux faire ça comme ça.

Sinon tu peux faire la même chose avec une seule table, des autojointures, et une simulation de requete hierarchique (si tu veux une profondeur arbitraire) ou un nombre d'autojointure fixe si tu veux une profondeur maximale.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
id   |   parent_id    |   categorie  |  priorité (optionnel )
0       NULL             (root)
1       0                  A                  1   
2       1                  a                  1
3       2                  (vide)            1
4       2                  b                  2
5       4                  (vide)            1
6       0                  B                  2

et avec ça tu codes
(root) A a (vide)
(root) A a b (vide)
(root) B

mais c'est un peu compliqué

[Sof34]

Merci Gene69 de ta réponse.

Mais j'ai rien compris parceque comme tu le dis :

mais c'est un peu compliqué

Je voudrais préciser que je ne connais pas la longueur des chaines et donc du nombre de sous catégories qu'on peux rencontrer.

Sinon tu peux faire la même chose avec une seule table, des autojointures, et une simulation de requete hierarchique (si tu veux une profondeur arbitraire) ou un nombre d'autojointure fixe si tu veux une profondeur maximale.

Pourquoi pas en fait j'y avait pas pensé ça semble même plutôt mieux... Mais ça me dit tjs pas comment faire.

[vorace]

c'est pas très clair tout ca...

1er point : tu fais un do...while sur le résultat d'une requête, ton premier traitement se fait sur une première ligne non définie...

2eme point : tu fais teste tes deux cellule et tu mes des td ou pas, ca te fait donc un tr sans td ?

3eme point si a chaque cellule de ton tableau résultant de l'explode, tu test deux cellule successive alors que chaque cellule correspond à un niveau de sous catégories ? Logiquement c'est pas possible...tu compare pas deux catégories de niveaux diffèrent...

moi je dis ca sent la récursivité...je plaisante ou peut être pas.

Précise le nombre de niveau de catégories ?
As tu des saut du genre catégories/pas de sous catégories/sous sous catégories...

[Oriented User]

Bonjour,

Sauf erreur de ma part c'est une arborescence que tu veux ?

Comme te l'indique gene69 une structure arborescente est composée d'éléments racine ( root ) et des éléments constituants des sous-ensembles rattachés aux éléments racines, eux-mêmes pouvant contenir d'autres sous-ensembles.

A - a - b ...

B - a - b - c - d ...

C - a - b ...

Peuvent être insérés dans une table comme suis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13

id    |    id_parent    |    order    |    libelle

1        NULL                1                A
2        NULL                2                B    
3        NULL                3                C
4        1                    1                a
5        1                    2                b
6        2                    1                a
7        2                    2                b
8        2                    3                c
9        2                    4                d

etc...

id_parent représentant le niveau dans la hiérarchie, order l'ordre d'affichage.

Lorsque tu extrais ces données d'une table, tu les insères généralement dans un tableau ( Array ). Grâce à une fonction récursive tu peux récupérer la hiérarchie d'un seul coup en faisant abstraction du nombre de sous-éléments.

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

function read_arbo( $id = NULL )
{
    // Initialise le tableau contenant les éléments ou sous-éléments
    $array = array();
    // Compteur
    $i = 0;
    // Définis le niveau de chaque élément
    static $level = 0;
    // REQUETE SQL
    $RQ = "SELECT * FROM maTable WHERE id_parent=" ( ( $id===NULL )? "   IS NULL " : " = " . $id . " " ) . " ORDER BY U_R.order ASC;";
    // Traitement du résultat de la requête
    $RQ = mysql_query( $RQ );
    while( $RS     = mysql_fetch_object( $RQ ) )
    {
        // Si il s'agit d'un noeud racine, on l'insère comme un noeud parent
        if( $RS->id_parent == NULL )
        {
             $level = 0;
             $array[$i] = $node;
             $array[$i]->level = $level;
        }
        // Si il s'agit d'un noeud enfant, on l'insère comme tel
        if( $node = read_arbo( $RS->id ) )
        {
             $level++;
             $array[$i]->childNode = $node;
             $array[$i]->childNode[]->level = $node;
        }
        // Incrémentation du compteur
        $i++;
    }
    // Sortie
    return $array;
}

$result =  read_arbo();

Tu vas obtenir un résultat du genre :

print_r( $result );

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
Array
(
    [0] => stdClass Object
        (
            [id] => 1
            [id_parent] => NULL
            [order] => 1
            [libelle] => A
            [level] => 1
            [childNode] => Array
                           (         
                                 [0] => stdClass Object
                                     (
                                        [id] => 4
                                        [id_parent] => 1
                                        [order] => 1                                        
                                        [libelle] => a
                                        [level] => 2
                                     ),
                                 [0] => stdClass Object
                                     (
                                        [id] => 5
                                        [id_parent] => 1                                     
                                        [order] => 2
                                        [libelle] => a
                                        [level] => 2
                                     ),
                                 ...
                           )
      ...
   }

Ensuite libre à toi de traiter ce tableau pour l'afficher comme
tu veux en fonction des niveaux ($level).

J'espère t'avoir apporté une réponse possible et de ne pas être trop
trop hors sujet.

Bon courage.