[OOP] Gebruikerssysteem
Ik ben weer eens lekker aan het programmeren, en dit keer ook weer OOP-stijl. Ik was daarom van plan om een heel gebruikerssysteem te maken met OOP. Ik heb veel gehad aan de uitleg van Wouter J, en dan bedoel ik deze post: klik
Het probleem waar ik op vastloop is het volgende. Wanneer je een gebruikerssysteem hebt, dan is het natuurlijk logisch dat gebruikers weer inloggen en dat ze dan een object hebben met hun gegevens daarin.
Nu is de vraag, wát moet daar precies in, en welke methods gebruik je hiervoor? Moet je bijvoorbeeld ook gegevens als een registratiedatum, laatst actief e.d. in het object bewaren (zelfs als je ze niet gebruikt)?
M'n tweede punt is hoe je zo'n bestaande gebruiker weer terug omzet in object. Als je bij het voorbeeld van Wouter J de constructor gebruikt met een paar argumenten zoals de gebruikersnaam en het wachtwoord, dan kun je deze niet meer gebruiken om een nieuw object aan te maken waarin we gelijk alle gegevens (zoals registratiedatum) meesturen. Hoe los ik dat op? Uiteraard gebruiken we een mapper voor de communicatie tussen het gebruikersobject en de database.
Dit leek me wel een leuk discussiepunt en een leerzaam topic. Althans, voor mij :-)
Roel
Roel op 12/06/2012 23:18:24:
Nu is de vraag, wát moet daar precies in, en welke methods gebruik je hiervoor? Moet je bijvoorbeeld ook gegevens als een registratiedatum, laatst actief e.d. in het object bewaren (zelfs als je ze niet gebruikt)?
Als het onderdeel is van het object 'gebruiker' dan ja. Alleen hoef je het niet altijd te laden natuurlijk. Op de ene pagina heb je wel de registratiedatum nodig, op de andere niet. Bij mij past alles in de class (als ik zo'n class zou hebben, maar dat terzijde), maar bepaalt 'het model' (de classes die de database besturen) welke data er wordt opgehaald. De gebruikers class heeft dus de mogelijkheid om alles op te slaan en te verwerken, maar het is niet noodzakelijk.
Roel op 12/06/2012 23:18:24:
M'n tweede punt is hoe je zo'n bestaande gebruiker weer terug omzet in object. Als je bij het voorbeeld van Wouter J de constructor gebruikt met een paar argumenten zoals de gebruikersnaam en het wachtwoord, dan kun je deze niet meer gebruiken om een nieuw object aan te maken waarin we gelijk alle gegevens (zoals registratiedatum) meesturen. Hoe los ik dat op? Uiteraard gebruiken we een mapper voor de communicatie tussen het gebruikersobject en de database.
Gebruik een array om de gegevens mee te geven aan de class. Gegevens uit de database krijg je normaal gesproken in een array, dus het is vrij simpel om die mee te geven in de gebruikers class. In de gebruikers class kan je die dan ook als array opslaan. Voor het uitlezen ervan kan je dan kiezen voor of specifieke methodes per veld, of je gebruikt de magische getter (__get()) waardoor je vooraf niet eens hoeft te weten welke velden precies allemaal in de class kunnen zitten. Dit laatste is niet altijd aan te raden, want je verliest daarmee wel de mogelijkheid om de methodes in slimme editors in de code hints te zien.
Gewijzigd op 28/01/2014 20:52:09 door Wouter J
Hoe zie jij een gebruikersobject dan voor je? Een object met slecht één array en een __get() en __set() method?
Wat ik heb is een resultset class die de gegevens uit de database beheert en daar waar gevraagd beschikbaar stelt, inclusief de juiste formatting van bijvoorbeeld getallen en datums. Deze resultset class werkt dan weer met specifieke classes die de 'kennis' hebben van de data die wordt gebruikt om de formatting goed te doen. Zo heb ik een extra class voor users, voor landen, voor plaatsen etc. Iedere class weet wat er moet gebeuren met de data om het op een juiste manier te tonen. De resultset class bewaart het alleen maar en is in feite dom.
In jouw geval gaat het er dus om dat je moet bepalen of je gebruikersclass ook daadwerkelijk functionaliteit moet toevoegen of niet. Moet het iets kunnen doen als er een bepaalde waarde van een gebruiker wordt veranderd bijvoorbeeld? Zo niet, dan kan je waarschijnlijk volstaan met een zeer klein aantal methodes. Een __construct() om de data mee te geven en een __get() om het eruit te halen, met mogelijk nog een __call() als je bij het ophalen nog extra info wil meegeven (bijvoorbeeld een default waarde als de waarde niet bestaat). Ik heb er ook nog een exists() bij zodat andere classes kunnen checken of de waarde bestaat of niet.
Vervolgens kan je in de mapper een fromArray en een toArray functie maken die dan het object van en naar een array omzet om op te slaan of op te halen van een database.
Verder ben ik ook fan van een service layer en een mapper layer te maken.
Vb: http://i47.tinypic.com/2unvts4.png
Hier dienen de mappers ENKEL voor het omzetten van object en database.
De Table (adapter) layer dient dan voor het uitvoeren van de database instructies
De service layer dient dan voor het opslaan/ophalen/verwijderen van gegevens. Deze roept ook steeds de mapper op om de gegevens om te zetten naar de juiste objecten. Je roept in de Models/controllers dus enkel de service layer aan.
Natuurlijk is dit wel tijdsintensief.
Wat Erwin aanhaalt is natuurlijk ook een oplossing. Dit heb ik zelf ook eens gebruikt. Ik had een abstract object waarin dan die array zat, de __get en __set. Ik heb ook nog een echte functie 'get' en 'set' toegevoegd. Dan ben ik nog iets verder gegaan en heb ik de ArrayAccess interface geimplementeerd (http://www.php.net/manual/en/class.arrayaccess.php) Hierdoor kan je dus een object als array gebruiken. Hierdoor kon ik een object op volgende manieren gebruiken:
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
$obj = new Product();
$product->id = 1;
$product['id'] = 1;
$product->set('id', 1);
$product->flushDescription();
Service_Product::save($product);
?>
$obj = new Product();
$product->id = 1;
$product['id'] = 1;
$product->set('id', 1);
$product->flushDescription();
Service_Product::save($product);
?>
Deze manier van werken bespaart natuurlijk veel tijd, maar is niet al te proper en geeft ook geen code completition in uw editor.
index.php
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
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
<?php
require 'classes/gastenboek.php';
$gastenboek = new Gastenboek(new PDO('mysql:host=localhost;dbname=test', 'root', ''), (isset($_GET['id']) ? $_GET['id'] : ''));
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (!isset($_POST['naam']) && $_POST['naam'] == '' || !isset($_POST['reactie']) || $_POST['reactie'] == '')
{
$resultaat = 'Je hebt niet beide velden ingevuld!';
}
else
{
$gastenboek->toevoegen(new Reactie($_POST['naam'], $_POST['reactie'], $_SERVER['REMOTE_ADDR']));
$result = 'Je reactie is succesvol toegevoegd aan het gastenboek!';
}
}
?>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Gastenboek door Roel</title>
</head>
<body>
<h1>Gastenboek door Roel</h1>
<?php
if (isset($result))
{
echo $result;
}
?>
<form method="post" action="">
<p>
Naam:<br />
<input type="text" name="naam" />
</p>
<p>
Reactie:<br />
<textarea name="reactie" rows="6" cols="37"></textarea>
</p>
<p>
<input type="submit" value="Reageren" /> <input type="reset" value="Herstel" />
</p>
</form>
<h2>Geplaatste reacties</h2>
<?php
foreach ($gastenboek->getReacties() as $reactie)
{
echo '<p>Door <strong>'.$reactie->getNaam().'</strong> op <strong>'.$reactie->getDatum().'</strong></p>
<p>'.$reactie->getReactie().'</p><hr />';
}
?>
</body>
</html>
require 'classes/gastenboek.php';
$gastenboek = new Gastenboek(new PDO('mysql:host=localhost;dbname=test', 'root', ''), (isset($_GET['id']) ? $_GET['id'] : ''));
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (!isset($_POST['naam']) && $_POST['naam'] == '' || !isset($_POST['reactie']) || $_POST['reactie'] == '')
{
$resultaat = 'Je hebt niet beide velden ingevuld!';
}
else
{
$gastenboek->toevoegen(new Reactie($_POST['naam'], $_POST['reactie'], $_SERVER['REMOTE_ADDR']));
$result = 'Je reactie is succesvol toegevoegd aan het gastenboek!';
}
}
?>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Gastenboek door Roel</title>
</head>
<body>
<h1>Gastenboek door Roel</h1>
<?php
if (isset($result))
{
echo $result;
}
?>
<form method="post" action="">
<p>
Naam:<br />
<input type="text" name="naam" />
</p>
<p>
Reactie:<br />
<textarea name="reactie" rows="6" cols="37"></textarea>
</p>
<p>
<input type="submit" value="Reageren" /> <input type="reset" value="Herstel" />
</p>
</form>
<h2>Geplaatste reacties</h2>
<?php
foreach ($gastenboek->getReacties() as $reactie)
{
echo '<p>Door <strong>'.$reactie->getNaam().'</strong> op <strong>'.$reactie->getDatum().'</strong></p>
<p>'.$reactie->getReactie().'</p><hr />';
}
?>
</body>
</html>
classes/gastenboek.php
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
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
<?php
/**
* Class voor een gastenboek
*
* @author Roel
*/
// Benodigde classes inladen
require 'reactiemapper.php';
require 'reactie.php';
class Gastenboek
{
/**
* De ReactieMapper om de communicatie tussen het Gastenboek object en de database te regelen
*
* @var resource $_reactieMapper
*/
private $_reactieMapper;
/**
* Het ID van het Gastenboek object
*
* @var integer $_id
*/
private $_id;
/**
* Constructor van een nieuw Gastenboek object
*
* @param resource $pdo Het PDO databaseobject
* @param integer $id Het ID van het Gastenboek - niet verplicht
*/
public function __construct(PDO $pdo, $id = '')
{
$this->_reactieMapper = new ReactieMapper($pdo, $id);
$this->_id = (int) $id;
}
/**
* Het ophalen van alle reacties
*
* @return array Een array met daarin de reacties
*/
public function getReacties()
{
return $this->_reactieMapper->getReacties($this->_id);
}
/**
* Het invoegen van een nieuwe reactie
*
* @param resource $reactie Het Reactie object
*/
public function toevoegen(Reactie $reactie)
{
$this->_reactieMapper->toevoegen($reactie);
}
}
?>
/**
* Class voor een gastenboek
*
* @author Roel
*/
// Benodigde classes inladen
require 'reactiemapper.php';
require 'reactie.php';
class Gastenboek
{
/**
* De ReactieMapper om de communicatie tussen het Gastenboek object en de database te regelen
*
* @var resource $_reactieMapper
*/
private $_reactieMapper;
/**
* Het ID van het Gastenboek object
*
* @var integer $_id
*/
private $_id;
/**
* Constructor van een nieuw Gastenboek object
*
* @param resource $pdo Het PDO databaseobject
* @param integer $id Het ID van het Gastenboek - niet verplicht
*/
public function __construct(PDO $pdo, $id = '')
{
$this->_reactieMapper = new ReactieMapper($pdo, $id);
$this->_id = (int) $id;
}
/**
* Het ophalen van alle reacties
*
* @return array Een array met daarin de reacties
*/
public function getReacties()
{
return $this->_reactieMapper->getReacties($this->_id);
}
/**
* Het invoegen van een nieuwe reactie
*
* @param resource $reactie Het Reactie object
*/
public function toevoegen(Reactie $reactie)
{
$this->_reactieMapper->toevoegen($reactie);
}
}
?>
classes/reactiemapper.php
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
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
<?php
/**
* Class voor de communicatie tussen het Gastenboek object en de database
*
* @author Roel
*/
class ReactieMapper
{
/**
* Het PDO databaseobject
*
* @var resource $_db
*/
private $_db;
/**
* Het ID van het Gastenboek waaraan de ReactieMapper gekoppeld is
*
* @var integer $_gastenboekId
*/
private $_gastenboekId;
/**
* Constructor van een nieuw ReactieMapper object
*
* @param resource $pdo Het PDO databaseobject
* @param integer $gastenboekId Het ID van het Gastenboek
*/
public function __construct($pdo, $gastenboekId)
{
$this->_db = $pdo;
$this->_gastenboekId = (int) $gastenboekId;
}
/**
* Het ophalen van alle reacties van het Gastenboek op te halen uit de database
*
* @return array Een array met daarin de reacties
*/
public function getReacties()
{
// Lege array maken waarin de reacties komen te staan
$reacties = array();
// Query maken en uitvoeren
$query = "SELECT naam, reactie, DATE_FORMAT(datum, '%d-%m-%Y om %H:%i') AS datum, ip FROM reacties WHERE gastenboek_id = :id";
$statement = $this->_db->prepare($query);
$statement->execute(array(
':id' => $this->_gastenboekId
));
// Alle reacties in de array plaatsen
while ($record = $statement->fetch(PDO::FETCH_ASSOC))
{
$reacties[] = new Reactie($record['naam'], $record['reactie'], $record['ip'], $record['datum']);
}
// De array met daarin de reacties terugsturen naar het Gastenboek object
return $reacties;
}
/**
* Het toevoegen van een nieuwe reactie aan de database
*
* @param resource $reactie Het Reactie object
*/
public function toevoegen(Reactie $reactie)
{
$query = "INSERT INTO reacties (gastenboek_id, naam, reactie, ip, datum) VALUES (:gastenboek_id, :naam, :reactie, :ip, NOW())";
$statement = $this->_db->prepare($query);
$statement->execute(array(
':gastenboek_id' => $this->_gastenboekId,
':naam' => $reactie->getNaam(),
':reactie' => $reactie->getReactie(),
':ip' => $_SERVER['REMOTE_ADDR']
));
}
}
?>
/**
* Class voor de communicatie tussen het Gastenboek object en de database
*
* @author Roel
*/
class ReactieMapper
{
/**
* Het PDO databaseobject
*
* @var resource $_db
*/
private $_db;
/**
* Het ID van het Gastenboek waaraan de ReactieMapper gekoppeld is
*
* @var integer $_gastenboekId
*/
private $_gastenboekId;
/**
* Constructor van een nieuw ReactieMapper object
*
* @param resource $pdo Het PDO databaseobject
* @param integer $gastenboekId Het ID van het Gastenboek
*/
public function __construct($pdo, $gastenboekId)
{
$this->_db = $pdo;
$this->_gastenboekId = (int) $gastenboekId;
}
/**
* Het ophalen van alle reacties van het Gastenboek op te halen uit de database
*
* @return array Een array met daarin de reacties
*/
public function getReacties()
{
// Lege array maken waarin de reacties komen te staan
$reacties = array();
// Query maken en uitvoeren
$query = "SELECT naam, reactie, DATE_FORMAT(datum, '%d-%m-%Y om %H:%i') AS datum, ip FROM reacties WHERE gastenboek_id = :id";
$statement = $this->_db->prepare($query);
$statement->execute(array(
':id' => $this->_gastenboekId
));
// Alle reacties in de array plaatsen
while ($record = $statement->fetch(PDO::FETCH_ASSOC))
{
$reacties[] = new Reactie($record['naam'], $record['reactie'], $record['ip'], $record['datum']);
}
// De array met daarin de reacties terugsturen naar het Gastenboek object
return $reacties;
}
/**
* Het toevoegen van een nieuwe reactie aan de database
*
* @param resource $reactie Het Reactie object
*/
public function toevoegen(Reactie $reactie)
{
$query = "INSERT INTO reacties (gastenboek_id, naam, reactie, ip, datum) VALUES (:gastenboek_id, :naam, :reactie, :ip, NOW())";
$statement = $this->_db->prepare($query);
$statement->execute(array(
':gastenboek_id' => $this->_gastenboekId,
':naam' => $reactie->getNaam(),
':reactie' => $reactie->getReactie(),
':ip' => $_SERVER['REMOTE_ADDR']
));
}
}
?>
classes/reactie.php
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
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
<?php
/**
* Class voor een reactie in het gastenboek
*
* @author Roel
*/
class Reactie
{
/**
* De naam van degene die de reactie heeft geplaatst
*
* @var string $_naam
*/
private $_naam;
/**
* De reactie
*
* @var string $_reactie
*/
private $_reactie;
/**
* De datum van de reactie
*
* @var string $_datum
*/
private $_datum;
/**
* Het IP-adres van degene die de reactie heeft geplaatst
*
* @var string $_ip
*/
private $_ip;
/**
* Constructor voor een nieuw Reactie object
*
* @param string $naam De naam van degene die de reactie geplaatst heeft
* @param string $reactie De reactie
* @param string $ip Het IP-adres van degene die de reactie geplaatst heeft
* @param string $datum De datum van de reactie - niet verplicht wanneer de reactie nog geplaatst moet worden
*/
public function __construct($naam, $reactie, $ip, $datum = '')
{
$this->_naam = (string) $naam;
$this->_reactie = (string) $reactie;
$this->_ip = (string) $ip;
$this->_datum = (string) $datum;
}
/**
* Het ophalen van de naam van degene die de reactie geplaatst heeft
*
* @return string De naam van degene die de reactie geplaatst heeft
*/
public function getNaam()
{
return $this->_naam;
}
/**
* Het phalen van de reactie
*
* @return string De reactie
*/
public function getReactie()
{
return $this->_reactie;
}
/**
* Het ophalen van de datum van de reactie
*
* @return string De datum van de reactie
*/
public function getDatum()
{
return $this->_datum;
}
}
?>
/**
* Class voor een reactie in het gastenboek
*
* @author Roel
*/
class Reactie
{
/**
* De naam van degene die de reactie heeft geplaatst
*
* @var string $_naam
*/
private $_naam;
/**
* De reactie
*
* @var string $_reactie
*/
private $_reactie;
/**
* De datum van de reactie
*
* @var string $_datum
*/
private $_datum;
/**
* Het IP-adres van degene die de reactie heeft geplaatst
*
* @var string $_ip
*/
private $_ip;
/**
* Constructor voor een nieuw Reactie object
*
* @param string $naam De naam van degene die de reactie geplaatst heeft
* @param string $reactie De reactie
* @param string $ip Het IP-adres van degene die de reactie geplaatst heeft
* @param string $datum De datum van de reactie - niet verplicht wanneer de reactie nog geplaatst moet worden
*/
public function __construct($naam, $reactie, $ip, $datum = '')
{
$this->_naam = (string) $naam;
$this->_reactie = (string) $reactie;
$this->_ip = (string) $ip;
$this->_datum = (string) $datum;
}
/**
* Het ophalen van de naam van degene die de reactie geplaatst heeft
*
* @return string De naam van degene die de reactie geplaatst heeft
*/
public function getNaam()
{
return $this->_naam;
}
/**
* Het phalen van de reactie
*
* @return string De reactie
*/
public function getReactie()
{
return $this->_reactie;
}
/**
* Het ophalen van de datum van de reactie
*
* @return string De datum van de reactie
*/
public function getDatum()
{
return $this->_datum;
}
}
?>
Ik vind hem zelf best goed gelukt. Wat vinden jullie ervan?
Gewijzigd op 28/01/2014 20:53:07 door Wouter J
Mijn voorstel voor dit kleine projectje: maak een singleton. Bijvoorbeeld:
Code (php)
1
2
3
2
3
<?php
$this->_db = DatabaseAdapter::getInstance();
?>
$this->_db = DatabaseAdapter::getInstance();
?>
Deze klasse kan je dan PDO laten extenden en zo dus gebruiken voor uw database connecties. zo blijven uw objecten overzichtelijker.
Ook het meegeven van alle parameters in de constructor zou ik zo niet doen. Je kan in de mapper een statische functie stoppen: fromArray(). Deze zou dan uw reactie object kunnen opbouwen uit form/database data. Zo kan je ergens anders in uw project die reactie gebruiken zonder dat je alle parameters moet invullen. In deze gastenboek is het natuurlijk niet nodig, maar in grotere projecten kan dat wel handig zijn.
Volgende stap is MVC ;)
veranderen naar:
if ($_SERVER['REQUEST_METHOD'] === 'POST')
Verder bedankt voor je tips!
@Bert B: zou je inderdaad kunnen toelichten waarom?
Gewijzigd op 16/06/2012 12:11:40 door Roel -
Sommige mensen vinden dat leuk en handig, alleen ik vind het alleen maar rot. Een singleton en TDD (test driven development) gaan namelijk totaal niet samen...
@Bert, naast het feit dat je eigenlijk in elke if === moet gebruiken en == gewoon helemaal moet vergeten (behalve bij objecten want daar werkt een == als een ===...), hoeft het natuurlijk niet verplicht.
Toevoeging op 16/06/2012 18:14:42:
Even de code wat beter bekeken. En hier mijn puntjes:
Gebruik DI voor je Mappers. Je moet niet een PDO object meegeven aan Gastenboek en in Gastenboek::__construct() dit object omzetten in een ReactieMapper, maar je moet juist de ReactieMapper al maken en die meegeven aan Gastenboek::__construct():
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$reactionMapper = new ReactionMapper(new PDO('...'));
$guestbook = new Guestbook($reactionMapper);
?>
$reactionMapper = new ReactionMapper(new PDO('...'));
$guestbook = new Guestbook($reactionMapper);
?>
Tevens twijfel ik over het gebruik van de reactionMapper op deze manier. Misschien is dit wel handiger:
Code (php)
1
2
3
2
3
<?php
$reactionMapper->create(new Reaction('...'), $guestbook);
?>
$reactionMapper->create(new Reaction('...'), $guestbook);
?>
En dan in ReactionMapper::create() de reactie in de DB stoppen, bij het id van het guestbook (die je ophaalt met Gastenboek::getId()), en dan een method Gastenboek::toevoegen() maken die slechts alleen dat reactie object toevoegt aan een array reacties.
Elke keer een query uitvoeren als je Gastenboek::getReacties() gebruikt lijkt mij wat traag... Ik zou een aparte, protected/private, method maken die de reacties eenmaal ophaalt en die in een property plaats:
Code (php)
Maar met mijn verhaal hierboven over een andere manier van de mapper gaat dit helemaal niet op, want dan gebeurt het maar 1 keer.
Tevens, script je nou in het engels of in het nederlands? (mijn voorkeur gaat uit naar engels) Want in index.php heb je op regel 10 $resultaat en op regel 15 $result waarbij je in de body alleen gebruik maakt van $result...
Bij default waardes, ookal zijn die leeg, is het alsnog verstandig om je te houden aan het type. Dus:
Code (php)
Nog even wat commentaar over je PHPdoc.
De PHPdocs die je nu op file niveau (helemaal bovenin je code) hebt staan zijn eigenlijk PHPdocs op class niveau:
Bij sommige dingen is het heel heel heel logisch wat ze betekenen, je hoeft dan geen PHPdoc te hebben, dat gaat dan eerder storend werken. Bijv:
Code (php)
Zou ik maken:
Ook zijn die variabelenamen op property niveau, zoals in het voorbeeld hierboven, totaal overbodig.
Gebruik voor het type van een parameter oid die een object is niet het type resource maar de naam van het object:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class Gastenboek
{
/**
* Constructor van een nieuw Gastenboek object
*
* @param PDO $pdo Het PDO databaseobject
* @param integer $id Het ID van het Gastenboek - niet verplicht
*/
public function __construct(PDO $pdo, $id = '')
{
$this->_reactieMapper = new ReactieMapper($pdo, $id);
$this->_id = (int) $id;
}
}
?>
class Gastenboek
{
/**
* Constructor van een nieuw Gastenboek object
*
* @param PDO $pdo Het PDO databaseobject
* @param integer $id Het ID van het Gastenboek - niet verplicht
*/
public function __construct(PDO $pdo, $id = '')
{
$this->_reactieMapper = new ReactieMapper($pdo, $id);
$this->_id = (int) $id;
}
}
?>
(je had hier ook een typo, kijk daar nog even na).
Als laatst vind ik die underscore voor private properties niet heel handig, alle properties die je hebt zijn private of protected, dus eigenlijk is het totaal overbodig. Maar dit is natuurlijk persoonlijk.
@VeeWee, ik zou geen gebruik gaan maken met singletons, nergens voor nodig en soms heb je meerdere database connecties nodig, als je gaat wisselen van db bijv.
Tevens vroeg ik me af wat er erg is aan meerdere properties meegeven aan een constructor? Ik gebruik dat namelijk altijd.
Wel zou ik een populate method maken in de DataMapper klassen. Deze maakt dan van een array een object.
Wouter J op 16/06/2012 12:43:40:
@Bert, naast het feit dat je eigenlijk in elke if === moet gebruiken en == gewoon helemaal moet vergeten (behalve bij objecten want daar werkt een == als een ===...), hoeft het natuurlijk niet verplicht.
Wouter, graag een toelichting. Waarom zou je in elke if === moeten gebruiken? Dat kost meer performance dan == en het is niet altijd nodig.
Graag jouw verklaring.
Code (php)
Dat laatste kan bijv. een probleem zijn met hashes van een wachtwoord. Zie ook: http://phpsadness.com/sad/47
Ik zou altijd strictly type aanraden, daarom gebruik ik altijd type casting en ook vaak ===.
Even in het kort voor beginners: == kijkt of een waarde dezelfde waarde heeft, bijv. 0 == '0', === kijkt ook naar het type, bijv. 0 !== '0', maar 0 === 0.
Behalve bij objecten, daarbij kijkt == naar het type en de waardes en === of het van hetzelfde instance is.
Offtopic:
Ozzie, leuk, of nouja leuk, artikel voor je om te lezen: http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/
Even terugkomend op dit voorbeeldje:
if ($_SERVER['REQUEST_METHOD'] == 'POST')
Dit kan toch nooit fout gaan? Hier is dan toch geen === benodigd?
Ik vraag dit omdat === trager is dan ==. Als je overal === gebruikt wordt je site trager.
Gewijzigd op 17/06/2012 01:05:12 door Ozzie PHP
En die hashes, tja, dat is weer 1 van die kromme dingen in PHP. Ik vind die uitleg in de tutorial geweldig. PHP is te vergelijken met een gereedschapskist waarin allemaal tools zitten die het net niet zijn, net niet optimaal voor het werkt, maar met een beetje creativiteit kun je er wel mee werken.
En mocht je het met hashes niet geloven, probeer zelf maar uit!
Singletons hebben inderdaad zijn voor- en nadelen. Als je ze niet wilt gebruiken, dan doe je dat gewoon niet... Toch zijn er ook wel handige uitwerkingen van dit patroon. Zelf vind ik het niet zo plezant om overal een pdo object mee te gaan geven. Ik stop die liever op 1 plaats, waar ik het object steeds kan terugvinden. Misschien minder handig voor TDD. Maar dat gebruik je dikwijls kleine projecten toch niet, omdat dat meer tijd in neemt.
Ik vind het persoonlijk onhandig om alle mogelijke properties mee te geven met de constructer. Op die manier moet je weten dat het eerste argument bijvoorbeeld id is etc. Dan maak ik liever een leeg object aan en vervolgens setId() etc.
Die populate-functie (of fromArray die ik dan persoonlijk dikwijls gebruik) is natuurlijk ook super handig!
Dit zijn natuurlijk persoonlijke meningen. Het is een kwestie van hoe je gewoon bent om alles te schrijven. Als jij het op een andere manier aanpakt, voor mij even goed hoor :)
Volgens die uitleg, als ik het goed begrijp, als je "123450000" vergelijkt met "1234567890" geeft ie true? Kun jij het even in je eigen woorden uitleggen misschien want ik mis even iets geloof ik.
Het verschil tussen == en === zal inderdaad niet veel zijn, maaaaaaar... waarom zou je overal === gebruiken terwijl dat niet overal nodig is. If-statements gebruik je echt heeeel vaak. Stel dat je per pagina request 300 if-statements hebt (ik noem maar even wat) en je gebruikt overal === terwijl dat maar bij 50 van de 300 if-statements nodig is, dan doe je dus 250x een if-statement te veel. Dat zou zomaar 0,1 tot 0,2 seconden kunnen schelen (let wel, ik heb dit nooit gemeten... maar het is ook meer even een voorbeeldje).