VNC stopt er mee :(
[oop] Domain-object: atributen vs array
ik denk dat dit onderwerp al een aantal keren besproken is maar hoe zouden jullie te werk gaan met een domain object (= een class / object dat data vasthoud / valideert)?
Verkiezen jullie gedefinieerde attributen zoals:
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
<?php
namespace Jds\Models\User;
class User
{
private $id;
private $email;
private $password;
/* particulier */
private $firstname;
private $lastname;
private $birthdate;
/* Zakelijk */
private $naam;
private $btw_nummer;
private $contactpersoon;
private $type;
private $adress;
private $city;
private $country;
private $postalCode;
public function __construct($email)
{
$this->setEmail($email);
}
public function getKey()
{
return 'user';
}
public function setId($newId)
{
$this->id = $newId;
}
public function setName($newName)
{
$this->name = $newName;
}
public function setPassword($newPassword)
{
$this->password = $newPassword;
}
public function setEmail($newEmail)
{
$this->email = $newEmail;
}
public function setAdress($adress)
{
$this->adress = $adress;
}
public function setCity($city)
{
$this->city = $city;
}
public function setPostalCode($postalcode)
{
$this->postalCode = $postalcode;
}
public function setType($type)
{
$this->type = $type;
}
public function setCountry($country)
{
$this->country = $country;
}
public function setFirstName($firstname)
{
$this->firstname = $firstname;
}
public function setLastName($lastname)
{
$this->lastname = $lastname;
}
public function setBirthDate($birthdate)
{
$this->birthdate = $birthdate;
}
public function getId()
{
return $this->id;
}
public function getName()
{
return $this->getLastName() . ' ' . $this->getFirstName();
}
public function getFirstName()
{
return $this->firstname;
}
public function getLastName()
{
return $this->lastname;
}
public function getPassword()
{
return $this->password;
}
public function getEmail()
{
return $this->email;
}
public function getAdress()
{
return $this->adress;
}
public function getCity()
{
return $this->city;
}
public function getPostalCode()
{
return $this->postalCode;
}
public function getCountry()
{
return $this->country;
}
public function getType()
{
return $this->type;
}
public function getBirthDate()
{
return $this->birthdate;
}
public function getBTW()
{
return $this->btw_nummer;
}
}
?>
namespace Jds\Models\User;
class User
{
private $id;
private $email;
private $password;
/* particulier */
private $firstname;
private $lastname;
private $birthdate;
/* Zakelijk */
private $naam;
private $btw_nummer;
private $contactpersoon;
private $type;
private $adress;
private $city;
private $country;
private $postalCode;
public function __construct($email)
{
$this->setEmail($email);
}
public function getKey()
{
return 'user';
}
public function setId($newId)
{
$this->id = $newId;
}
public function setName($newName)
{
$this->name = $newName;
}
public function setPassword($newPassword)
{
$this->password = $newPassword;
}
public function setEmail($newEmail)
{
$this->email = $newEmail;
}
public function setAdress($adress)
{
$this->adress = $adress;
}
public function setCity($city)
{
$this->city = $city;
}
public function setPostalCode($postalcode)
{
$this->postalCode = $postalcode;
}
public function setType($type)
{
$this->type = $type;
}
public function setCountry($country)
{
$this->country = $country;
}
public function setFirstName($firstname)
{
$this->firstname = $firstname;
}
public function setLastName($lastname)
{
$this->lastname = $lastname;
}
public function setBirthDate($birthdate)
{
$this->birthdate = $birthdate;
}
public function getId()
{
return $this->id;
}
public function getName()
{
return $this->getLastName() . ' ' . $this->getFirstName();
}
public function getFirstName()
{
return $this->firstname;
}
public function getLastName()
{
return $this->lastname;
}
public function getPassword()
{
return $this->password;
}
public function getEmail()
{
return $this->email;
}
public function getAdress()
{
return $this->adress;
}
public function getCity()
{
return $this->city;
}
public function getPostalCode()
{
return $this->postalCode;
}
public function getCountry()
{
return $this->country;
}
public function getType()
{
return $this->type;
}
public function getBirthDate()
{
return $this->birthdate;
}
public function getBTW()
{
return $this->btw_nummer;
}
}
?>
of eerder een array:
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
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
<?php
class User
{
private $properties = array();
public function setProperty($key, $value)
{
$this->$properties[$key] = $array;
}
public function getProperty($key)
{
return $this->$properties[$key];
}
public function setProperties(array $values)
{
$this->$properties = $values;
}
public function getProperties()
{
return $this->$properties;
}
}
?>
class User
{
private $properties = array();
public function setProperty($key, $value)
{
$this->$properties[$key] = $array;
}
public function getProperty($key)
{
return $this->$properties[$key];
}
public function setProperties(array $values)
{
$this->$properties = $values;
}
public function getProperties()
{
return $this->$properties;
}
}
?>
Ik vind het langs de éne kant wel goed dat ik alleen aan mijn vastgestelde attributen geraak via de getters (voorbeeld1). Het nadeel is dat ik nooit snel alle attributen kan ophalen (bijvoorbeeld voor een insert.)
Gewijzigd op 08/03/2013 10:56:20 door Jasper DS
Als de properties wel bekend zijn, zoals bij een user, dan zou ik met specifieke setters en getters werken en met specifieke class properties, zoals in voorbeeld 1. Die class properties zijn daar namelijk voor bedoeld. Een voornaam is een property/eigenschap van een user/gebruiker.
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
public function getProperties() {
$properties = get_object_vars($this);
foreach ($properties as $property => $value) {
echo $property . ' ' . $value . '<br>';
}
}
?>
public function getProperties() {
$properties = get_object_vars($this);
foreach ($properties as $property => $value) {
echo $property . ' ' . $value . '<br>';
}
}
?>
Ik heb dit niet getest, maar als het goed is zou je nu alle properties met hun waarden op het scherm moeten zien. In plaats van een echo, ga je dan een INSERT toepassen.
Een class property is een eigenschap van een object. Een voornaam, achternaam, geboortedatum enz. zijn allemaal eigenschappen van een user. Uiteraard kunnen we die allemaal in één property gooien. Dan zou je voortaan in iedere class nog maar één property nodig hebben waar je alles in stopt. Volgens mij is dat niet de juiste gedachte.
Als je een object schematisch weergeeft (bijvoorbeeld via var_dump) dan zou je in jouw geval zoiets krijgen:
Code (php)
1
2
2
object: user
properties: properties
properties: properties
In mijn geval zou je dan zoiets krijgen:
Code (php)
1
2
3
4
5
2
3
4
5
object: user
properties: day_of_birth
email_address
first_name
last_name
properties: day_of_birth
email_address
first_name
last_name
Persoonlijk vind ik dat mijn afspiegeling van het object een duidelijkere en volledigere weergave geeft van wat het object inhoudt.
Ozzie PHP op 08/03/2013 11:50:57:
Erwin, dat is toch gewoon een kwestie van persoonlijke voorkeur? Jij vraagt waarom zou je dat doen? Dan vraag ik waarom zou je het niet doen?
Dat klopt natuurlijk helemaal en ik heb een duidelijke reden waarom ik dat in dit geval niet zou doen. Namelijk omdat het makkelijker en efficienter is zoals ik boven heb uitgelegd. Dat maakt het inderdaad niet de ultieme waarheid, maar wel waarom ik het zo zou doen, in dit geval (en het dus adviseer).
Ozzie PHP op 08/03/2013 11:50:57:
Een class property is een eigenschap van een object. Een voornaam, achternaam, geboortedatum enz. zijn allemaal eigenschappen van een user. Uiteraard kunnen we die allemaal in één property gooien. Dan zou je voortaan in iedere class nog maar één property nodig hebben waar je alles in stopt. Volgens mij is dat niet de juiste gedachte.
Wat mij betreft haal je nu de begrippen property en variabele door elkaar. Een property, in mijn ogen, is een eigenschap van een object en kan je opvragen en/of bepalen door middel van getters en setters. Ik ben het met je eens dat het mooier (en in de meeste gevallen beter) is om voor elk property een eigen getter en setter te maken zodat het duidelijk is wat de properties zijn.
Jij trekt dit nu echter door naar de variabele waarin een property wordt opgeslagen. dat vind ik te ver gaan. Elk property hoeft niet zijn eigen variabele te hebben. Sterker, in veel gevallen kan dat niet eens, of is het in elk geval niet verstandig. Neem een container object dat bijvoorbeeld een reeks aan andere objecten beheert. Een heel nuttig property (read only weliswaar) van dat container object zal zijn het aantal objecten dat dat object beheert. Daar heb je dus een getter voor. Alleen geen variabele, want op het moment dat je het uitleest, zal het object het aantal objecten tellen en dat teruggeven.
Dus hoe je de gegevens opslaat voor de properties staat los van de properties. In sommige gevallen, zoals hier, zal het gebruik van je class bepalen hoe je het het beste kunt opslaan. Als je, zoals in dit geval, van te voren al weet dat je alle properties samen vaak nodig zult gaan hebben in een array, waarom sla je het dan niet gewoon op in een array? Scheelt je een hoop moeilijkheden als je ze allemaal wilt uitlezen.
Gewijzigd op 08/03/2013 12:15:19 door Erwin H
Precies... en ik vind dat een voornaam, achternaam of e-mailadres allemaal properties zijn van een User.
"Ik ben het met je eens dat het mooier (en in de meeste gevallen beter) is om voor elk property een eigen getter en setter te maken"
Mooi, dan zijn we het daar over eens :-)
"Een heel nuttig property (read only weliswaar) van dat container object zal zijn het aantal objecten dat dat object beheerd."
Dan kom je weer terug op wat ik in het begin zei. Ik zou voor properties die bekend zijn een eigen property aanmaken. In container classes ligt de situatie anders, omdat je vantevoren niet weet wat je er allemaal in gaat stoppen. Stel we hebben een class met daarin de bestelling van een klant. De klant heeft 5 producten gekocht. Dan kun je de property count instellen op 5 omdat je het exacte aantal kent. Voor een container (of aanverwante class) geldt dat niet, alhoewel je ook hier een property zou kunnen instellen en ophogen op het moment dat er iets wordt toegevoegd. Maar je moet je sowieso afvragen of "aantal" een eigenschap is van een object.
Anyhow, misschien is het leuk als iemand anders ook zijn blik erop laat schijnen. Hoe meer inzichten, des te interessanter.
Ozzie PHP op 08/03/2013 12:24:26:
Precies... en ik vind dat een voornaam, achternaam of e-mailadres allemaal properties zijn van een User.
Ozzie, je mist mijn hele punt volgens mij.....
Probeer te begrijpen dat ik onderscheid maak tussen property en variabele. Dat begrip mis ik namelijk in je antwoord.
Code (php)
is beter dan:
Code (php)
Want in het tweede geval mis je de benoemde properties. Ben ik met je eens.
Wat ik echter zeg is dat er een tussenvorm is, die in dit geval veel handiger is. Laat los dat elke property zijn eigen variabele moet hebben (maar wel zijn eigen getters en setters) en dan krijg je dit:
Code (php)
De externe interface is identiek aan het door jou geprefereerde model met aparte properties. Ik kan zien dat deze class een property voornaam heeft, ik ken het setten en getten. Echter, ik sla het op een array, want dan kan ik veel makkelijker alle properties in een keer teruggeven als dat nodig is.
Opmerking: ja, je moet dan wel zorgen dat het ontvangende object weet dat mogelijk niet alle properties geset zijn.
Wellicht kan iemand anders er ook eens zijn licht over laten schijnen.
Dan verschillen we dus van mening, maar begrijpen we elkaar wel weer. Verder aan Jasper welke kant hij op wil.
edit:
ik denk dat ik het zo ga doen (zie onder), vinden jullie dat een acceptabel idee?
Code (php)
1
2
3
4
2
3
4
public function getProperties()
{
return get_object_vars($this);
}
{
return get_object_vars($this);
}
Gewijzigd op 08/03/2013 15:22:10 door Jasper DS
Erwin H op 08/03/2013 15:25:41:
Inderdaad, en de wortels van waar het straks fout gaat, vind je in dit fragment:Dit kan ook mogelijk ook het geval zijn als je deze class later gaat extenden. Zo krijg je dus wel onverwacht gedrag.
Code (php)
Een particulier heeft een $firstname en $lastname, een bedrijf een $naam met een $contactpersoon?
Je kunt eigenlijk weinig zinnigs zeggen over getters en setters als je model nog niet af is. Dat zie je in de startpost: alle setters doen $this->A = $a en alle getters doen return $this->A, maar verder doen ze helemaal niets.
Een e-mailadres wordt daarmee hetzelfde als een naam en die zijn beide vergelijkbaar met een btw-nummer. Als je het zó doet, dan kun je evengoed alles in een array stoppen. Maar uiteindelijk wil je dat waarschijnlijk niet.
Jasper DS op 08/03/2013 15:17:38:
Bedankt voor jullie mening! Ik ben nog steeds aan het twijfelen. ;-) Ik was ook nog aan het denken om een functie als http://php.net/manual/en/function.get-object-vars.php te gebruiken maar dat werkt alleen voor public properties en die van mij staan op private omdat ze niet van buiten af mogen aangesproken worden (daar dient de getter en setter voor).
edit:
ik denk dat ik het zo ga doen (zie onder), vinden jullie dat een acceptabel idee?
edit:
ik denk dat ik het zo ga doen (zie onder), vinden jullie dat een acceptabel idee?
Code (php)
1
2
3
4
2
3
4
public function getProperties()
{
return get_object_vars($this);
}
{
return get_object_vars($this);
}
Euh, deze functie gaf ik je in mijn eerdere post al... gemist?