[oop] Domain-object: atributen vs array

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Jasper DS

Jasper DS

08/03/2013 10:53:17
Quote Anchor link
Hallo,

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)
PHP script in nieuw venster Selecteer het PHP script
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
<?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;
    }

}

?>


of eerder een array:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
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
<?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;    
    }

}

?>


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
 
PHP hulp

PHP hulp

09/08/2020 06:56:33
 
Erwin H

Erwin H

08/03/2013 10:58:08
Quote Anchor link
Getters en setters zou je kunnen doen. Opslaan zou ik altijd in een array doen. Hoe een class intern werkt is niet van belang voor de buitenwacht, dus bij naam gedefinieerde properties dient geen enkel doel. Een array is dan veel efficienter omdat je flexibeler bent en properties die geen waarde hebben bestaan op dat moment ook niet in het geheugen. Daarnaast kan je ook nog eens runtime properties definieren (mocht dat nodig zijn) via anonieme getters en setters.
 
Ozzie PHP

Ozzie PHP

08/03/2013 11:07:14
Quote Anchor link
Het hangt er vanaf of je weet wat voor properties je wilt opslaan. Er zijn situaties waar je van tevoren niet weet wat je allemaal wilt opslaan. In dat geval is de 2e optie (opslaan in een array) de juiste. Hou er rekening mee dat overal waar in jouw code $this->$properties staat dit $this->properties moet zijn.

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.
 
Jasper DS

Jasper DS

08/03/2013 11:23:38
Quote Anchor link
Dan moet ik mijn insert functie aanpassen. Daar komt nu het user object binnen maar ik wil een snelle methode om inneens al mijn properties in de query te kunnen zetten zonder dat ik al mijn getters moet aanroepen.
 
Ozzie PHP

Ozzie PHP

08/03/2013 11:36:52
Quote Anchor link
Jasper, volgens mij hoeft dat niet. Volgens mij kun je een functie getProperties maken. Zoiets:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
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>';
    }
}

?>


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.
 
Erwin H

Erwin H

08/03/2013 11:40:49
Quote Anchor link
Waarom zou je dat doen Ozzie? Lijkt mij een beetje het paard achter de wagen spannen. Hoe je een property intern opslaat is niet erg van belang. Of je alle gegevens nu in aparte variabelen hebt zitten, of in 1 array, het property wordt gedefinieerd door hoe je het kunt setten en getten, niet door hoe het opgeslagen is. Om nu strikt vol te houden aan aparte variabelen omdat dat de definitie van een property zou zijn (...) maakt het alleen maar lastiger.
 
Ozzie PHP

Ozzie PHP

08/03/2013 11:50:57
Quote Anchor link
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? Zoals voor veel dingen in het programmeren geldt dat er meerdere wegen zijn die naar Rome leiden.

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)
PHP script in nieuw venster Selecteer het PHP script
1
2
object:     user
properties: properties


In mijn geval zou je dan zoiets krijgen:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
object:     user
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.
 
Erwin H

Erwin H

08/03/2013 12:13:49
Quote Anchor link
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
 
Ozzie PHP

Ozzie PHP

08/03/2013 12:24:26
Quote Anchor link
"Een property, in mijn ogen, is een eigenschap van een object en kan je opvragen en/of bepalen door middel van getters en setters."

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.
 
Erwin H

Erwin H

08/03/2013 12:27:53
Quote Anchor link
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.
 
Ozzie PHP

Ozzie PHP

08/03/2013 12:34:28
Quote Anchor link
Dan moet je even uitleggen wat je bedoelt. Ik zie een naam als een property (eigenschap) van een gebruiker (object).
 
Erwin H

Erwin H

08/03/2013 12:52:36
Quote Anchor link
Jij zegt:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class Test{
  private $voornaam;

  public function getVoornaam(){
    return $this->voornaam;
  }


  public function setVoornaam( $voornaam ){
    $this->voornaam = $voornaam;
  }
}

?>

is beter dan:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class Test{
  private $data = array();

  public function get( $key ){
    return $this->data[$key];
  }


  public function set( $key, $value ){
    $this->data[$key] = $value;
  }
}

?>

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)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
//even zonder isset tests om het makkelijk te houden.
class Test{
  private $data = array();

  public function getVoornaam(){
    return $this->data['voornaam'];
  }


  public function setVoornaam( $voornaam ){
    $this->$data['voornaam'] = $voornaam;
  }
}

?>

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.
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
<?php
  public function getAll(){
    return $data;
  }

?>

Opmerking: ja, je moet dan wel zorgen dat het ontvangende object weet dat mogelijk niet alle properties geset zijn.
 
Ozzie PHP

Ozzie PHP

08/03/2013 13:02:41
Quote Anchor link
Ik snap wat je bedoelt, dus wat dat betreft zeg je hiermee niks nieuws. Ik denk alleen dat het instellen van een property $data te globaal is. Voor een container of config class waarbij je vantevoren de properties niet kent is het prima. Echter, als je de properties wel kent denk ik dat het veel netter is om ze ook te gebruiken. Aan de werking doet het inderdaad niks af, maar aan het OOP principe wellicht wel.

Wellicht kan iemand anders er ook eens zijn licht over laten schijnen.
 
Erwin H

Erwin H

08/03/2013 13:08:51
Quote Anchor link
Nee ik bedenk niet opeens iets nieuws :-)

Dan verschillen we dus van mening, maar begrijpen we elkaar wel weer. Verder aan Jasper welke kant hij op wil.
 
Jasper DS

Jasper DS

08/03/2013 15:17:38
Quote Anchor link
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?
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
public function getProperties()
    {
        return get_object_vars($this);
    }
Gewijzigd op 08/03/2013 15:22:10 door Jasper DS
 
Erwin H

Erwin H

08/03/2013 15:25:41
Quote Anchor link
Je moet alleen oppassen dat je niet op zeker moment de class uitbreidt met properties die niets te maken hebben met de user data (uitgaande van dat dit over een user object gaat). Als je bijvoorbeeld een property hebt voor een ander object, bijvoorbeeld een service container link oid, dan wordt die zo ook mee teruggegeven. Dit kan ook mogelijk ook het geval zijn als je deze class later gaat extenden. Zo krijg je dus wel onverwacht gedrag.
 
Ward van der Put
Moderator

Ward van der Put

08/03/2013 16:20:42
Quote Anchor link
Erwin H op 08/03/2013 15:25:41:
Dit kan ook mogelijk ook het geval zijn als je deze class later gaat extenden. Zo krijg je dus wel onverwacht gedrag.
Inderdaad, en de wortels van waar het straks fout gaat, vind je in dit fragment:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class User
{
    /* particulier */
    private $firstname;
    private $lastname;
    private $birthdate;

    /* Zakelijk */
    private $naam;
    private $btw_nummer;
    private $contactpersoon;
?>

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.
 
Ozzie PHP

Ozzie PHP

08/03/2013 16:29:43
Quote Anchor link
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?
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
public function getProperties()
    {
        return get_object_vars($this);
    }

Euh, deze functie gaf ik je in mijn eerdere post al... gemist?
 



Overzicht Reageren

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.