Menus de ilimitados subniveles

[ONahuelO]

Hola buen dia, me encuentro trabado en un problema y es que necesito hacer un menu que tenga ilimitados submenus y que estos tambien tengan ilimitados menus.

Ejemplo:

Menu principal
SubMenu
SubMenu
Menu del Submenu
Submenu
Menu del Submenu
Otro Submenu


Osea la idea es que tampoco sean estaticos sino que tambien se puedan insertar y eliminar.

Yo tengo algo hecho pero solo logro hacer submenus.

Aca esta mi codigo:

Código PHP:

  $conn = new PDO('mysql:host='.$db['host'].';dbname='.$db['name'], $db['user'],$db['pass']); 
     
    $query = "SELECT * FROM menus WHERE menu_owner=0"; 
     
    $menu = $conn->prepare($query); 
     
    $menu->execute(); 
     
    $retorno = $menu->fetchall(PDO::FETCH_OBJ); 
     
    foreach($retorno as $obj) 
    { 
        $querya = "SELECT * FROM menus WHERE menu_owner=".$obj->menu___id; 
         
        $smenu = $conn->prepare($querya); 
         
        $smenu->execute(); 
         
        $sretorno = $smenu->fetchall(PDO::FETCH_OBJ); 
         
        $obj->menu_sub = $sretorno; 
         
    } 
     
    echo json_encode($obj);  
   

Esta es mi DB

Código:

 menu___id  	menu_name 	menu_owner 	
1 	Comercios	0
2 	Panaderias	1
3 	Electrodomesticos	1
5 	Electronica	3
6 	Hogar	3

Y este es el resultado:

Código:

{"menu___id":"1","menu_name":"Comercios","menu_owner":"0","menu_sub":[{"menu___id":"2","menu_name":"Panaderias","menu_owner":"1"},{"menu___id":"3","menu_name":"Electrodomesticos","menu_owner":"1"}]}

Osea mi idea es hacer una consulta general y hacer una sub consulta por cada submenu pero solo logro hacerla de un nivel.

Creo que tambien deveria una manera de hacerlo solo con SQL pero cualquier forma que pueda hacerlo me serviria.

Muchas Gracias

[Atomycko]

Haber si esto te funciona: http://www.forosdelweb.com/f18/paginacion-php-1100545/#post4604507

[ONahuelO]

Creo que lo entendi pero no se como aplicarlo a mi problema, creo que deveria de armar un array nuevo con el menu final, el tema es que no logro hacer un bucle que busque los hijos que pueda contener el menu.

[arcanisgk122]

si estas trabajando con my sql la base de datos puede ser de esta clase:

Código PHP:

nombre      nivel   relacion
menu1       0       0       //esto general la cabeza del menu
submenu1    1       1       //indica que pertenece al menu 1
art-lista   1       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu1 como hijo
art-lista   1       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu1 como hijo
submenu2    2       1       //indica que pertenece al menu 1
art-lista   2       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu2 como hijo
art-lista   2       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu2 como hijo
 

la mejor forma es recorrerlo con ciclos for o while y guardarlos en un array y ir construyendo el menu.

al hacerlo con ciclos seria ilimitado al tamaño de la base de datos.

[ONahuelO]

Iniciado por arcanisgk122

si estas trabajando con my sql la base de datos puede ser de esta clase:

Código PHP:

nombre      nivel   relacion
menu1       0       0       //esto general la cabeza del menu
submenu1    1       1       //indica que pertenece al menu 1
art-lista   1       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu1 como hijo
art-lista   1       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu1 como hijo
submenu2    2       1       //indica que pertenece al menu 1
art-lista   2       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu2 como hijo
art-lista   2       2       //indica que pertenece al menu 1 pero debe ir debajo de submenu2 como hijo
 

la mejor forma es recorrerlo con ciclos for o while y guardarlos en un array y ir construyendo el menu.

al hacerlo con ciclos seria ilimitado al tamaño de la base de datos.

Si el tema que no me sale es el de como hacer los ciclos, osea mi logica es recorrer los resultados con un foreach y ver si es un subitem añadirlo al item principal dentro del array que creo, el tema es que tengo que hacer esa funcion indefinidas veces.

Osea

Código PHP:

   
    $conn = new PDO('mysql:host='.$db['host'].';dbname='.$db['name'], $db['user'],$db['pass']); 
     
    $query = "SELECT * FROM menus"; 
     
    $menu = $conn->prepare($query); 
     
    $menu->execute(); 
     
    $retorno = $menu->fetchall(PDO::FETCH_OBJ); 
     
    $rmenu    =    array(); 
     
    foreach ($retorno as $obj) 
    { 
         
         
        if($obj->menu_owner != '0') 
        { 
                       //Hago una subconsulta  y lo añado al array  
        } 
         
         
    } 
     
     
     
    echo json_encode($rmenu);  
   

El problema es cuando halla muchos subitems, no entiendo como hacer el ciclo indefinidamente siempre que halla subitems dentro de los anteriores subitems

[Eleazan]

Prefiero usar una funcion recursiva

Es decir, una pequeña función que sea algo así:

Código PHP:

  
mostrar_menu($menu_owner) {
    $query = "SELECT * FROM menus WHERE `menu_owner`=".$menu_owner; 
    $sql->query($query);
    if($sql->num_rows) {
        echo '<ul>';
        while($item = $sql->fetch()) {
            echo '<li>';
            echo $item['menu_name'];
            mostrar_menu($item['menu_id'];
            echo '</li>';
        }
        echo '</ul>';
    }
}  
   

Algo así deberia servir... cambiando las sql para adaptarlas al tuyo (usando PDO!), y alguna cosilla que se me haya escapado!

Es una idea general... tendrás q adaptarla un poco ;)

Saludos

[dashtrash]

Ni se te ocurra hacer bucles, ni ciclos ni nada de eso.
Si lo que vas a pintar es un menú, entiendo que al final vas a necesitar *todas* las filas de la tabla de menu.
Si vas a necesitar *todas*, haces ***1*** solo select, y cargas **todas** las filas.Y en memoria, y usando referencias php, se reordenan según padre/hijo.
Cualquier código que contenga una query dentro de un bucle, necesita una desinfección urgente.Y si encima es recursivo, muuucho más.

[Eleazan]

Iniciado por dashtrash

Cualquier código que contenga una query dentro de un bucle, necesita una desinfección urgente.Y si encima es recursivo, muuucho más.

Claro. SQL no tiene caché. Y depende del tamaño de la tabla, y las opciones de tu servidor, te quedas sin memoria si metes toda la tabla en un array...

A mi la experiencia me dice que normalmente, tienes un host con memoria limitada (es más, suele ser compartido...). Y no sueles poder cambiar ese parámetro. Y he trabajado bastante con bbdd de hasta 40k de lineas, y tablas pesadas... y si cargas todo eso en memoria, te va a dar un fatal_error. Asiq si puedes trabajar linea a linea, ahorras memoria (a base de cargar un pelin la bbdd? ¿ser un poco más lento?).

[dashtrash]

Iniciado por Eleazan

Claro. SQL no tiene caché. Y depende del tamaño de la tabla, y las opciones de tu servidor, te quedas sin memoria si metes toda la tabla en un array...

A mi la experiencia me dice que normalmente, tienes un host con memoria limitada (es más, suele ser compartido...). Y no sueles poder cambiar ese parámetro. Y he trabajado bastante con bbdd de hasta 40k de lineas, y tablas pesadas... y si cargas todo eso en memoria, te va a dar un fatal_error. Asiq si puedes trabajar linea a linea, ahorras memoria (a base de cargar un pelin la bbdd? ¿ser un poco más lento?).

Claro.La cache de sql tiene el mismo rendimiento si haces siempre la misma query, que si haces 1000.y como mysql tiene cache, el tiempo de ejecucion de tu pagina es el mismo hagas una query, que si haces mil.Y claro, si la tabla es tan grande que ni cabe en memoria, cargarla en bucles,teniendo en cuenta que vas a procesar todas las filas, solo mejora la situacion...Y todo eso, si no confundieras numero de consultas, con numeros de filas en memoria.A menos, claro, que tenga un menu con varias decenas de miles de subopciones, cosa que me parece improbable.
En mi experiencia, trabajando con bases de datos con decenas de tablas por encima del millon de filas, mejor que no me encuentre un programador haciendo queries del tipo que se muestran ahi arriba...

[arcanisgk122]

yo pense en un select de toda la tabla.
luego lo guardamos un un array
y luego recorremos el array y lo vamos guardado en sub variables o sub arrays...


para que el menu quede asi:

sub-array1{
Submenu1
art-list
art-list
}

sub-array2{
Submenu1
art-list
art-list
}
sigo sin entender la creación de un menú de esta clase...

[ONahuelO]

Es un menu chico asi que el tema de las consultas no creo que me sature mucho el servidor, igual me gustaria hacerlo de la manera mas correcta posible.

Yo estoy tratando de hacer una consulta general.

Código:

SELECT * FROM menus

Y despues armar un array con el menu, pero el tema esta en que puedo armar un array seleccionando los que son principales con un foreach y un if

Código PHP:

  foreach ($retorno as $obj) 
    { 
             
        if($obj->menu_owner == '0') 
        { 
            // solo los principales 
        }     
    }  
   

Despues de eso para cada principal, podria insertar submenus destro de cada item del array ( siempre y cuando contengan submenus)

El tema es que no se como hacer este proceso ilimitadas veces ( siempre y cuando tengan subitems ) por cada submenu.

[arcanisgk122]

sera ilimitado si lo usas usas:

Código PHP:

foreach ($retorno as $obj){ 
             
        if($obj->menu_owner == '0'){ 
            // guardar padres en array ordenado
        }
        if($obj->menu_owner == '1'){ 
            // guardar hijos en array ordenado 
        }
 
}
 

si quierespintar el menu:

Código PHP:

foreach ($retorno as $obj){ 
             
        if($obj->menu_owner == '0'){ 
            // guardar padres en array1 ordenado
                if($obj->menu_owner == '1'){ 
                    // guardar hijos del padre actual en array2 ordenado 
                }
        }
 
}
 

[ONahuelO]

La verdad no entiendo la logica de como hacerlo y por ahora voy a hacer un json manual con el menu y despues vere.

Dejo bien mi codigo y mi db por si alguien me puede dar una mano con esto.

Tabla:

Código:

 menu___id           	menu_name         	menu_owner 
	
     1                          	Comercios                         	0
     2                          	Panaderias                    	1
     3 	                        Electrodomesticos          	1
     5                          	Electronica                    	3
     6                          	Hogar                              	3
     18                          	Medicos	                                0

PHP:

Código PHP:

      require('core/config.php');
    
    $conn = new PDO('mysql:host='.$db['host'].';dbname='.$db['name'], $db['user'],$db['pass']);
    
    $query = "SELECT * FROM menus WHERE menu_owner=$menu_owner";
    
    $menu = $conn->prepare($query);
    
    $menu->execute();
    
    $rmenu = array();
    
    $retorno = $menu->fetchall(PDO::FETCH_OBJ);

    $cant = $menu->rowCount();
    
    $resultados = array();
    
    
    foreach($retorno as $obj)
    {
        if($obj->menu_owner == '0')
        {
        $resultados[$obj->menu___id]['id'] = $obj->menu___id;
        $resultados[$obj->menu___id]['name'] = $obj->menu_name;
        }
    }
    
    unset($obj);    foreach($retorno as $obj)
    {
        if($obj->menu_owner != '0')
        {
            $resultados[$obj->menu_owner]['id'] = $obj->menu___id;
            $resultados[$obj->menu_owner]['name'] = $obj->menu_name;
        }
    }

    echo json_encode($resultados);  
   

Resultado:

Código:

{"1":{"id":"1","name":"Comercios"},"18":{"id":"18","name":"Medicos"}}

Como deseo que quede:

Código JSON:

[{"menu___id":"1","menu_name":"Comercios","Submenus":[{"menu___id":"2","menu_name":"Panaderias"},{"menu___id":"3","menu_name":"Electrodomesticos"},{"menu___id":"5","menu_name":"Electronica"},{"menu___id":"6","menu_name":"Hogar"}]},{"menu___id":"18","menu_name":"Medicos"}]
 

[arcanisgk122]

si tu lógica es el problema, poco podemos ayudarte, ya que entonces la nuestra seria intermedia o avanzada y no nos entenderías... te recomendamos hacer una estructura logica sin codigo primero en una libre o papel o tablero y luego implementarla en el lenguaje (es mi método)

en mi caso yo trabajo mis menu asignando niveles a los usuario:
editor
secretario
auditor
administrador

y luego muestro el menu de la siguiente manera

seccion noticias = mostrar si solo si nivel es igual o mayor a Editor:
seccion documentos= mostrar si solo si nivel es igual o mayor a secretaria:
Seccion facturas = mostrar si solo si nivel es igual a auditor O a Administrador:

condiciones: == / =< / && / OR y con eso hago filtros...

[NSD]

Supongamos la tabla "menus" con los siguientes campos:
menu___id (INT PRIMARY KEY) | menu_name (STRING) | menu_owner (INT FOREIGN KEY menus.menu___id)

Supongamos que se quiere usar PDO.
Supongamos que se esta usando PHP 5 >= 5.3.

Supongamos, que los items del menu raiz, los que no son alojados en ningun otro menu, tienen el campo menu_owner con valor NULL o 0.

Supongamos que la cantidad de elementos de cada menu es ilimitada.
Supongamos que la cantidad de menus es ilimitada.

Suponiendo el escenario anterior, el siguiente codigo puede servir para armar la estructura del menu arbol:

Código PHP:

<?php
    $conn = new PDO('mysql:host='.$db['host'].';dbname='.$db['name'], $db['user'],$db['pass']);
    $menu = $conn->prepare("SELECT menu___id, menu_name, IFNULL(menu_owner, 0) FROM menus ORDER BY menu_owner ASC");
    $menu->execute();
 
    $anfitriones = [];
    while($row = $menu->fetch(PDO::FETCH_ASSOC))
    {
        if(!isset($anfitriones[$row["menu_owner"]]))
            $anfitriones[$row["menu_owner"]] = [];
        $anfitriones[$row["menu_owner"]][$row['menu___id']] = [
                                                                 "nombre" => $row['menu_name']
                                                               , "alojados" => []
                                                              ];
    }
 
    foreach($anfitriones[0] as $id_anfitrion => &$referencia)
       $new_referencias[$id_anfitrion] = &$referencia;
 
    $referencias = [];
    while(count($anfitriones) > 1)
    {
        foreach($new_referencias as $id_anfitrion => &$referencia)
            $referencias[$id_anfitrion] = &$referencia;
 
        $new_referencias = [];
        foreach($referencias as $id_anfitrion => &$alojado)
        {
            if(isset($anfitriones[$id_anfitrion]))
            {
                $alojado["alojados"] = $anfitriones[$id_anfitrion];
                foreach($alojado["alojados"] as $id_subalojado => &$datos_subalojado)
                    $new_referencias[$id_subalojado] = &$datos_subalojado;
                unset($anfitriones[$id_anfitrion], $referencias[$id_anfitrion]);
            }
        }
        $referencias = [];
    }
 
    var_dump($anfitriones);
 

Notece que consume tanta memoria como elementos halla en el menu, por lo que si bien, en teoria el algoritmo funciona con una cantidad ilimitada de elementos, en la practica solo funciona con tantos como entren en la memoria del servidor en simultaneo.

[dashtrash]

Iniciado por NSD

Notece que consume tanta memoria como elementos halla en el menu, por lo que si bien, en teoria el algoritmo funciona con una cantidad ilimitada de elementos, en la practica solo funciona con tantos como entren en la memoria del servidor en simultaneo.

Supongamos que queremos evitar eso.Tenemos un menu con M filas, y no queremos tenerlas todas en memoria.
La unica forma de hacer eso, es generar la salida del menu a la vez que se procesan las filas.Es decir, se lee 1 fila de la query, e inmediatamente se hace echo del html correspondiente a esa entrada de menu.
Si se hace:
- 1) concatenaciones del html en una funcion: estás consumiendo *más* memoria que la necesaria para las rows de la query (hay que sumar todo el markup html).
- 2) Envío a algún sistema de plantillas para separar el dibujo del menú, de la obtenición de los datos : te fuerza a meter todas las filas en un array, con lo cual, estas usando la misma cantidad de memoria.

Es decir, el consumo de memoria debido a tener todas las opciones de menu en memoria, no viene sólo porque se haga una query que obtenga todas las filas a la vez.Puede venir porque se concatene en una variable que tiene todo el menu a la vez.O porque se guarden sub-menus parciales en un mismo array.
Los dos casos que he puesto, son muy comunes, y no hay que dar la impresión de que si haces queries parciales, no consumes tanta memoria como entradas del menú.Puedes estar usando la misma, o incluso más.

[arcanisgk122]

por eso es que se usan reglas o filtro donde para x usuario se muestra X menu y se descarta las otras parte de menu para evitar el consumo de memoria...

[arcanisgk122]

facil:
le pones niveles a cada usuario dependiendo del menú que quieras mostrar

con una querry buscas el usuario y tomas los datos.
luego haces una segunda querry que busque en la base de datos el menu correspondiente al nivel del usuario...
para hacer esto tendrías que almacenar en la base de dato el codigo html ya terminado para cada nivel de usuario.
y seri facil de imprimir



$menu=query(optener menu para el usuario where nivel = $nivel)

echo $menu;

[ocp001a]

Suponiendo que tienes en la base de datos un menú así;

Código PHP:

$secciones=array(
    array('id'=>1,'seccion'=>'Administracion','pertenece'=>0),
    array('id'=>2,'seccion'=>'ventas','pertenece'=>1),
    array('id'=>3,'seccion'=>'config','pertenece'=>2),
    array('id'=>4,'seccion'=>'otro','pertenece'=>3),
    array('id'=>5,'seccion'=>'mas','pertenece'=>4),
    array('id'=>6,'seccion'=>'again','pertenece'=>5),
    array('id'=>7,'seccion'=>'dos','pertenece'=>0),
    array('id'=>8,'seccion'=>'tres','pertenece'=>0),
    array('id'=>9,'seccion'=>'cuatro','pertenece'=>0),
    array('id'=>10,'seccion'=>'cinco','pertenece'=>0),
    array('id'=>11,'seccion'=>'nuevo','pertenece'=>3),
    array('id'=>12,'seccion'=>'viejo','pertenece'=>3)
);
 

Donde 'id' es el id del registro en la tabla, 'sección' es el nombre del menú o nivel, y 'pertenece' es el id del menú o submenú al que pertenece el registro actual (el id 1 sólo puede pertenecer al id 0)

Con una función similar a esta:

Código PHP:

function asigna($menu,$id,$seccion,$pertenece){
    if(empty($menu))
        return array('menu___id'=>$id,'menu_name'=>$seccion);
    if(is_array($menu)){
        if(isset($menu['menu___id']) and $menu['menu___id']==$pertenece)
            $menu['Submenus'][]=array('menu___id'=>$id,'menu_name'=>$seccion);
        else{
            if(!isset($menu['Submenus']))
                $menu['Submenus']=array('menu___id'=>$id,'menu_name'=>$seccion);
            else
                $menu['Submenus']=asigna($menu['Submenus'],$id,$seccion,$pertenece);
        }
    }
    return $menu;
}
 

Puedes crear el menú con la estructura que mencionas, recorriendo los registros de tu tabla (en este caso usé un arreglo y recorro con un for, pero se adaptaría a un while con una tabla)

Código PHP:

$menu=array();
foreach($secciones as $i =>$m)
    $menu=asigna($menu,$m['id'],$m['seccion'],$m['pertenece']);
var_dump($menu);
echo json_encode($menu);
 

Edito: por cierto, desde luego, este método carga todo el árbol del menú en memoria.