BASIS databas-systeem (forumachtig)
Zoals: een recepten site, een resencie-site, enz. enz.
Ik had steeds een pagina met categoriën, eentje met items en je kon op items reageren.
Natuurlijk zaten er wel wat verschillen in (andre velden er wel of niet bij) en of een extra tabel (met ingredienten)
Ik moet nu weer een paar van die sites maken, en dat wil ik dus in OOP gaan doen (ben goed bekend (met de grondbeginsellen) maar bij het uitdenken loop ik steeds vast. Ik weet niet welke classes ik het beste kan maken. Wat vooral lastig is is dat ik een relationeel systeem heb. Dus met categorie_ID,item_ID,reactie_ID enz.
Als je het in een hiërarchie zou tekenen is item een subklasse van categorie en reactie er eentje van item. Maar zo wil ik het niet maken want ik wil rechtstreeks een item aan kunnen roepen aan de hand van zijn ID en niet via een categorie.
Mijn tweede was in één allesomvattende klasse te maken waar subklasses op gelijk niveau onder staan, maar dan moest ik weel een lelijke construciie maken met eval() om die subklasses toegang tot elkaar te geven.
Ik heb dus moeite met het uitdenken van de klasses, er hoeven geen myql-tabellen gemaakt te worden, alleen maar uitgelezen. Als jullie het nodig vinden licht ik nog wel toe met code.
In OOP zou bijvoorbeeld reactie GEEN subklasse zijn van item. Een reactie heeft immers andere eigenschappen dan item.
Je moet dan eerder denken aan een dataobject voor categorie en dataobject voor reactie. Deze beiden kunnen dan weer afgeleid zijn van de dataobject klasse.
Tis maar een begin natuurlijk, maar hopelijk begrijp je dat je op iets andere manier moet denken.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
<?php
class categorie{
var items; //array met items
function addItem($item){
$this->items[]=$item;
}
}
?>
[/CODE]
In dat voorbeeld noem ik item een subklasse van categorie,
sorry voor mijn onduidelijkheid.
class categorie{
var items; //array met items
function addItem($item){
$this->items[]=$item;
}
}
?>
[/CODE]
In dat voorbeeld noem ik item een subklasse van categorie,
sorry voor mijn onduidelijkheid.
Andere vraag is nu wat je applicatie precies moet doen en of dit nut heeft. Zonder die achtergrond informatie is het natuurlijk moeilijk zeggen wat je zou moeten doen om je doel te bereiken.
Iedereen heeft zo zijn eigen manier om een klasse-structuur op te zetten.
Vermijdt in ieder geval eval !!! aub.. eval == evil
Manier één:
Code (php)
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
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
<?php
class DBobject{
var $categorien;
function loadCats(){
unset($this->categorien[])
//mysql query
while($cat=mysql_fetch_array($result)){
$this->categorien[]=new categorie($result['categorie_ID']);
}
}
}
class categorie{
var $items;
var $table;
function loadItems(){
unset($this->items[])
//mysql query
while($item=mysql_fetch_array($result)){
$this->items[]=new item($result['item_ID']);
}
}
}
class item{
var $reacties;
function item($item_ID=''){
//variabelen inladen aan de hand van ID
}
}
?>
class DBobject{
var $categorien;
function loadCats(){
unset($this->categorien[])
//mysql query
while($cat=mysql_fetch_array($result)){
$this->categorien[]=new categorie($result['categorie_ID']);
}
}
}
class categorie{
var $items;
var $table;
function loadItems(){
unset($this->items[])
//mysql query
while($item=mysql_fetch_array($result)){
$this->items[]=new item($result['item_ID']);
}
}
}
class item{
var $reacties;
function item($item_ID=''){
//variabelen inladen aan de hand van ID
}
}
?>
Hier worden de reacties dus in een array in de items opgeslagen, die weer in een array in de categorien staan.
Dit vind ik zelf niet fijn omdat je bijvoorbeeld reacties via drie stappen moet benaderen en ik wil objecten (lees items) direct vanaf hun ID kunnen uitlezen.
Methode twee:
Code (php)
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?php
[code]<?php
function call_object_func($objectName,$opdracht){
//deze opdracht roept een functie aan binnen een object (NIET een class!!) deze functie kan ook binnen andere objecten worden gebruikt
#eerst maken we het object beschikbaar in de functie
eval('global $' . $objectName . ';');
#nu roepen we de functie aan
eval('$' . $objectName . '->' . $opdracht . ';');
}
class dbHandler{
var $dbhName;
var $classes;
function addClass($class){
$classname=$class->getName();
$this->classes[$classname]=$class;
$this->classes[$classname]->setDbhName($this->objectname);
}
}
class dbhClass{
var $dbhName;
var $classname;
var $items;
function loadItems(){
}
function getName(){
return $this->classname;
}
function setDbhName($name){
$this->dbhName=$name;
}
}
$forum = new dbHandler('forum');
$items=new dbhClass('items');
$items->settable('items');
$forum->addClass($cats);
$forum->addClass($items);
$forum->addClass($reacties);
?>
Nadeel daarvan is de eval-construcitie en dat de objecten hun eigen variabelennaam moeten dragen.
Dat is alles wat ik zou gauw kon bedenken, of weten jullie iets beters?
[code]<?php
function call_object_func($objectName,$opdracht){
//deze opdracht roept een functie aan binnen een object (NIET een class!!) deze functie kan ook binnen andere objecten worden gebruikt
#eerst maken we het object beschikbaar in de functie
eval('global $' . $objectName . ';');
#nu roepen we de functie aan
eval('$' . $objectName . '->' . $opdracht . ';');
}
class dbHandler{
var $dbhName;
var $classes;
function addClass($class){
$classname=$class->getName();
$this->classes[$classname]=$class;
$this->classes[$classname]->setDbhName($this->objectname);
}
}
class dbhClass{
var $dbhName;
var $classname;
var $items;
function loadItems(){
}
function getName(){
return $this->classname;
}
function setDbhName($name){
$this->dbhName=$name;
}
}
$forum = new dbHandler('forum');
$items=new dbhClass('items');
$items->settable('items');
$forum->addClass($cats);
$forum->addClass($items);
$forum->addClass($reacties);
?>
Nadeel daarvan is de eval-construcitie en dat de objecten hun eigen variabelennaam moeten dragen.
Dat is alles wat ik zou gauw kon bedenken, of weten jullie iets beters?
Gewijzigd op 01/01/1970 01:00:00 door Tivaro
Is snap je redenatie trouwens niet helemaal. Je zegt dat je drie stappen nodig hebt om de items in de categorie te kunnen benaderen. Wat weerhoudt je ervan om de items direct aan te maken als je het id toch al weet? Gewoon 'new Item'?
Die tweede wel heel erg vreemde opzet lijkt mij meer op het terughalen van procedural coding. Alsof je hoogtevrees hebt om meer dan 1 laag diep een instantie in te duiken. Compositie (wat je in je eerste voorbeeld deed) is juist mooi omdat de volledige structuur van de applicatie, van de database behouden blijft in je code. Als jij een topic met al zijn reacties wilt weergeven, dan heeft het daadwerkelijk de structuur van $topic->comments[4]->author->username. Persoonlijk vind ik dat juist het mooie aan data-objecten en compositie.
edit: en gebruik van eval is niet goed te praten. Dat hoeft echt bijna nooit in PHP. PHP is echt belachelijk flexibel met z'n variabele variabelen. En als laatste hoop zijn er nog call_user_func_* en als aller laatste hoop create_function. Maar eval? Die functie bestaat alleen maar omdat andere scripttalen er ook eentje hebben. Gebruik ervan is meestal of een denkfout, of extreem flexibel denkwerk (bijv. PHP4 en 5 tegelijk volledig uitbuiten, of door PHP gegenereerde klassen) en zelfs dan kan het meestal anders.
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?php
function call_object_func($objectName,$opdracht, $argumenten = null)
{
global ${$objectName};
return call_user_func_array(array(
${$objectName},
$opdracht
), $argumenten);
}
?>
function call_object_func($objectName,$opdracht, $argumenten = null)
{
global ${$objectName};
return call_user_func_array(array(
${$objectName},
$opdracht
), $argumenten);
}
?>
(maar het blijft een maffe oplossing. Maar wees blij, straks, als je een betere oplossing hebt gevonden, kan je er vast met een glimlach op terugkijken, denkend van "Hoe was ik daar nu weer op gekomen?!" ;)
Gewijzigd op 01/01/1970 01:00:00 door Jelmer -
Maar ik laad dus ALLES, word het daar (als het voller word) niet heel traag van?