[PHP/OOP] waar render functie plaatsen van een tree menu

[Verwijderd]

Middels onderstaande class kan ik prima een treemenu kwijt vanuit mn db. Het voordeel van dit object dat ik middels een render functie op verschillende plekken op verschillende manieren mn menu kan laten zien. Ik kan middels een renderfunctie de hele tree laten zien, maar ik kan ook uit het object halen waar je je op dat moment bevindt. Ik haal dus de parent van de parent van ... van de plek op waar ik me op dat moment bevindt. De reden dat ik dus voor dit object heb gekozen is dat ik op verschillende manieren informatie uit dezelfde bron kan halen op de door mij gewenste manier.

PHP:

class TreeMenuItem
{
    private $url;
    private $title;
    private $children = array();
    
    function SetMenuItemAttributes ($title, $url)
    {
        $this -> title = $title;
        $this -> url = $url;
    }
    
    function AddChild ($object)
    {
        array_push($this -> children, $object);     
    }
}

$navigation = new TreeMenuItem();
$navigation -> SetMenuItemAttributes("uitklapper","");

    $child1 = new TreeMenuItem();
    $child1 -> SetMenuItemAttributes("a","a.html");
    $navigation -> AddChild($child1);
    
    $child1 = new TreeMenuItem();
    $child1 -> SetMenuItemAttributes("a","b.html");
    $navigation -> AddChild($child1);

Nu zit ik met een vraag waarvan ik niet weet wat de beste methode is. Ik kan een los object / functie maken die een bepaald type menu voor me renderd of ik kan een render functie/methode binnen mn al bestaande class maken. Maar elk menuitem zal dus gebruik kunnen maken van die functie en dat wil ik ook weer niet. Zoals je misschien leest heb ik niet heel veel ervaring meet OOP; ik heb ooit wat op school moeten leren, maar dat is ver weggezakt en met de lectuur die ik daarvoor heb moeten aanschaffen kom ik er niet uit. Ligt de fout al bij het object TreeMenuItem? Is dat een rare manier van opslaan van een treemenu? Wie kan me een duwtje in de goede richting geven?

[Skaah]

Je kan gewoon elke TreeMenuItem object een render functie geven. Dat is logisch, want het menu rendert zichzelf toch? Of wil je de details van het renderen opslaan in een ander object.

Zo'n functie kun je dan recursief maken:

PHP:

function render()
{
 for($i = 0 ; $i < count($this->children); $i++)
 {
  $this->children[$i]->render();
 }
echo $this->title;
}

Zo kun je elk deel van het menu renderen, een heel menu, maar ook een subment.

[Rhapsody]

Een tijdje terug heb ik ook een treemenu gemaakt in php.
Ik heb het alsvolgt gedaan:

2 classes
- treemenu
- menu item

een treemenu kan meerdere treeemenu's bevatten en meerdere menu items.
Beide classes hebben een functie die de html output (render in dit geval dus)

En bij het in elkaar zetten van de tree roep je gewoon de render method aan van de 'main'-tree.
Die gaat alle childs af en roept daar de render method van aan.

[Verwijderd]

Ik weet inderdaad dat ik elk menuitem een renderfunctie kan geven. In die renderfunctie zou ik bijvoorbeeld de onderstaande string kunnen parsen per menuitem.

PHP:

'<a href="' . $this -> url . '">' . $this -> title . '</a>';

Meer zou ik er niet mee willen. Ik zou dan verder nog een functie / object + methode willen hebben die het hele menu verder opbouwdt zoals bijvoorbeeld hieronder.

code:

<ul>
   <li>1</li>
   <li>2</li>
   <li>3
      <ul>
         <li>3a</li>
         <li>3b</li>
         <li>3c</li>
      </ul>
   </li>
   <li>4</li>
</ul>

Dat kan prima met een recursiefe functie. Daar weet ik voldoende mee om te gaan en is ook het probleem niet. Het probleem waar ik mee zit is het ontwerpen van de objecten en het waar plaatsen van welke render functies/methodes zodat dat makkelijk aanpasbaar en uitbreidbaar is.

Ik heb nu niets meer dan een MenuItemObject waar ik een child aan kan toevoegen. Maar hoe zorg ik ervoor dat ik een echt TreeObject krijg met eventueel als subclasse een MenuItemObject? Ik heb het gevoel dat ik voor mezelf nog maar een halve oplossing heb verzonnen. Vandaar dat ik hoopte op wat tips. Rhapsody gaf al aan dat hij twee classes gebruikt; moet je die helemaal los van elkaar zien? Of hebben die wel een bepaalde relatie?

Ik zat zelf een beetje te denken aan een soort van opbouw als deze. Hebben deze classes nu een relatie nodig? Moet je gaan werken met een interface, polymorfie? Ik ben wel een klein beetje bekend met die begrippen, en als ik voorbeeldjes daarvan zie snap ik dat ook wel, maar nu ik zelf wat probeer vanaf 0 neer te zetten blijf ik steken.

TreeMenu
- menuitems
- sorterenop
- renderfunctie 1
- renderfunctie 2
- renderfunctie 3

TreeMenuItem
- id
- url
- title

[farlane]

Is afhankelijk van het feit of je treemenuitem genoeg informatie ( lees: de manier van weergave ) heeft om het menu te renderen. Je zou dit ook in een apart object kunnen doen die een reference heeft naar het treemenu. ( of andersom )

Owh, zover was je eigenlijk al.

Op de plek echter waar jij renderfuntieXX hebt staan kun je beter een andere constructie verzinnen die uitbreidbaar is zonder dat je nieuwe renderfuncties moet maken. ( Bijv door een constructie die een ander render object aanmaakt --> je verzint een andere manier om je tree weer te geven : je maakt een nieuwe render class )

[ Voor 45% gewijzigd door farlane op 11-02-2005 09:49 ]

[WormLord]

Ik heb in mijn treemenu class een functie zitten die door de structuur heen loopt. Aan deze functie geef ik dan de naam van de functie mee die voor elk treeitem dat ie tegen komt moet aanroepen.

Een andere manier van renderen wordt dan 1 functie on de items te verwerken. Deze functie hoeft dan geen structuur navigatie meer te doen.

[farlane]

Lijkt me een behoorlijk bruikbaar design

[Verwijderd]

Zit ik net wat te lezen komt er naar voren dat je uit moet kijken met classes die alleen iets doen. Dat ze geen verkapte functies zijn, anders kan je code wat ondoorzicht worden. Een RenderClass zou volgens de schrijver dan waarschijnlijk onverstandig zijn omdat deze alleen wat doet.

Mijn eerder gelanceerde idee zou dan helemaal niet zo gek zijn zit ik me te bedenken.

TreeMenu
- menuitems
- sorterenop
- renderfunctie 1
- renderfunctie 2
- renderfunctie 3

TreeMenuItem
- id
- url
- title

Op de zoektocht naar een ideaal objectmodel voor mn treemenu (jaja, er zijn natuurlijk meerdere wegen die naar Rome leiden..) ben ik nog wel benieuwd naar de visie op de schrijver van mensen die veel meer verstand hebben van OOP dan ik dat heb..

@farlane: jouw idee om de class eenvoudiger uitbreidbaar te maken is opzich wel leuk. Hoe ik dat zou moeten doen weet ik niet precies maar kan ik wel uitkomen. Het is alleen dan wel een beetje tegen de visie in van de schrijver waar ik net een stuk van las.

@wormlord: Je hebt dus gewoon een soort van render functie in je treemenu class zitten die je menu hierarchies kan doorlopen en per item een functie aanroept om de <a href=""></a> en alles daarin en omheen te renderen. Komt zo'n beetje uit op wat ik ook schets met mijn idee. Het ging mij namelijk niet om de implementatie van de renderfunctie maar om de plaatsing van de methode render binnen mn menu class...

[Michali]

het is belangrijk dat een class een duidelijke taak heeft, of hij nou stateless of statefull is. hij moet gewoon samenhangend zijn. een class met zowel data als methods kan net zo goed onduidelijk worden dus ik vind het een beetje een slap argument. een render class heeft een duidelijke functie: renderen. als hij echt een aantal methods bevat die alleen met die taak bezig zijn, dan is het goed om daar een aparte class voor te maken.

[NetForce1]

Verwijderd schreef op maandag 21 februari 2005 @ 15:59:
@farlane: jouw idee om de class eenvoudiger uitbreidbaar te maken is opzich wel leuk. Hoe ik dat zou moeten doen weet ik niet precies maar kan ik wel uitkomen. Het is alleen dan wel een beetje tegen de visie in van de schrijver waar ik net een stuk van las.

Dat kan heel mooi dmv het strategy pattern. Zie deze uitleg op phpPatterns

[WormLord]

Verwijderd schreef op maandag 21 februari 2005 @ 15:59:
@wormlord: Je hebt dus gewoon een soort van render functie in je treemenu class zitten die je menu hierarchies kan doorlopen en per item een functie aanroept om de <a href=""></a> en alles daarin en omheen te renderen. Komt zo'n beetje uit op wat ik ook schets met mijn idee. Het ging mij namelijk niet om de implementatie van de renderfunctie maar om de plaatsing van de methode render binnen mn menu class...

Inderdaad. Er is 1 class treelist die de hele boekhouding voor de tree-structure doet. Deze heeft een algemene functie om alle nodes van de tree op een gestructureerde manier te doorlopen en die voor elke node een functie aanroept die het daadwerkelijke werk doet. Deze structuur wordt onder andere gebruikt om een javascript menu te genereren, maar ook bij het genereren van html-bestanden voor een cd-versie van de site.

Het is dus meer een functie voor het verwerken van de structuur en niet alleen het renderen.

Ook is het zo ingericht dat een treeitem diverse soorten informatie kan bevatten, zodat het voor diverse doeleinden gebruikt kan worden. Een menu is namelijk niet het enige dat een boom-structuur heeft

[Michali]

dat vind ik niet echt scheiden van je domein code van de presentatie. persoonlijk zou ik het zo gewoon echt niet aanpakken.