[OOP] Gastenboek
Ik ben momenteel bezig met OOP maar ik blijf nog steeds ouderwets programmeren, omdat ik gewoon nog niet precies weet hoe ik OOP moet werken. Ik doe daarom veel oefeningen en nu ben ik een gastenboek aan het maken.
Ik doe dit dus op de OOP manier, en tevens gebruik ik MySQLi OOP.
Waar ik nu echter mee vastloop, is het ophalen van reacties.
Dit is m'n code:
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
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
<?php
class Gastenboek {
$mysqli = new mysqli('localhost', 'root', '', 'gastenboek');
public function getReacties() {
$query = "SELECT naam, reactie FROM gastenboek ORDER BY datum DESC";
$sql = $mysqli->query($query);
if ($sql) {
}
}
public function plaatsReactie(Reactie $reactie) {
$query = "INSERT INTO gastenboek (naam, reactie, ipadres, datum) VALUES ('".$mysqli->real_escape_string($reactie->getNaam())."', '".$mysqli->real_escape_string($reactie->getReactie())."', '".$mysqli->real_escape_string($reactie->getIP())."', NOW())";
$sql = $mysql->query($query);
if (!$sql) {
throw new Exception('De reactie kon niet toegevoegd worden!');
}
}
}
class Reactie {
private $_naam, $_reactie, $_ip;
public function __construct($naam, $reactie, $ip) {
$this->_naam = $naam;
$this->_reactie = $reactie;
$this->_ip = $ip;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
public function getIP() {
return $this->_ip;
}
}
?>
class Gastenboek {
$mysqli = new mysqli('localhost', 'root', '', 'gastenboek');
public function getReacties() {
$query = "SELECT naam, reactie FROM gastenboek ORDER BY datum DESC";
$sql = $mysqli->query($query);
if ($sql) {
}
}
public function plaatsReactie(Reactie $reactie) {
$query = "INSERT INTO gastenboek (naam, reactie, ipadres, datum) VALUES ('".$mysqli->real_escape_string($reactie->getNaam())."', '".$mysqli->real_escape_string($reactie->getReactie())."', '".$mysqli->real_escape_string($reactie->getIP())."', NOW())";
$sql = $mysql->query($query);
if (!$sql) {
throw new Exception('De reactie kon niet toegevoegd worden!');
}
}
}
class Reactie {
private $_naam, $_reactie, $_ip;
public function __construct($naam, $reactie, $ip) {
$this->_naam = $naam;
$this->_reactie = $reactie;
$this->_ip = $ip;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
public function getIP() {
return $this->_ip;
}
}
?>
Wat ik nu eigenlijk zou willen, is dat ik het volgende kan gebruiken om reacties te tonen:
Code (php)
Ik heb alleen totaal geen idee hoe ik dit zou moeten oplossen. De 'Reactie' class gebruik ik voor het aanmaken van een reactie. Althans, dat was de bedoeling, maar nu schiet me net te binnen dat ik die ook zou kunnen gebruiken om reacties te tonen.
Of de code verder werkt weet ik niet, ik heb hem namelijk nog niet getest.
Ik hoop dat iemand me kan helpen!
Nu gaan we kijken, welk object moet de reactie ophalen. Moet de reactie zichzelf ophalen? Of moet het gastenboek de reactie ophalen? Of heb je een aparte class nodig om de reacties op te halen?
Gewijzigd op 08/01/2012 17:57:36 door Wouter J
Maar van de andere kant, als ik die koppel aan het gastenboek ( $gastenboek->setGrabber(new Reactiegrabber()) ) zou het ook prima kunnen.
Of denk ik nu verkeerd?
We hebben het main object Gastenboek. Dit omvat alles. Een gastenboek heeft reacties als eigenschap en propertie. Doormiddel van methods kun je properties wijzigen. Een gastenboek kan dus reacties ophalen, toevoegen, verwijderen, bewerken, enz.
Ik schrijf het liefst altijd voordat ik begin alles uit zonder code te schrijven. Zo heb je een beeld van hoe de objecten zijn, wat ze inhouden, enz:
Code (php)
1
2
3
4
2
3
4
ClassName
- eigenschap
+ methode()
+ andereMethode( $var )
- eigenschap
+ methode()
+ andereMethode( $var )
Hierbij is - en + de visibility, public private en protected. Probeer eens zo'n diagram te maken voor een Gastenboek waarbij je in je achterhoofd houdt dat Gastenboek reacties als eigenschap heeft en deze kan bewerken.
Gewijzigd op 08/01/2012 18:08:46 door Wouter J
Erg bekend met het programma ben ik nog niet, maar dat geeft niet.
Ik heb het MySQLi gedeelte er voor nu maar even uit gehaald, want dat snap ik nog niet helemaal. Als ik dit plaatje implementeer kom ik hierop uit en dit werkt:
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
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
<?php
class Gastenboek {
private $_reacties = array();
public function getReacties() {
return $this->_reacties;
}
public function plaatsReactie(Reactie $reactie) {
$this->_reacties[] = $reactie;
}
}
class Reactie {
private $_naam, $_reactie, $_ip;
public function __construct($naam, $reactie, $ip = '') {
$this->_naam = $naam;
$this->_reactie = $reactie;
$this->_ip = $ip;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
}
$gastenboek = new Gastenboek();
$gastenboek->plaatsReactie(new Reactie('Roel', 'Voorbeeld'));
foreach ($gastenboek->getReacties() as $reactie) {
echo 'Naam: '.$reactie->getNaam().'<br />';
echo 'Reactie: '.$reactie->getReactie();
}
?>
class Gastenboek {
private $_reacties = array();
public function getReacties() {
return $this->_reacties;
}
public function plaatsReactie(Reactie $reactie) {
$this->_reacties[] = $reactie;
}
}
class Reactie {
private $_naam, $_reactie, $_ip;
public function __construct($naam, $reactie, $ip = '') {
$this->_naam = $naam;
$this->_reactie = $reactie;
$this->_ip = $ip;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
}
$gastenboek = new Gastenboek();
$gastenboek->plaatsReactie(new Reactie('Roel', 'Voorbeeld'));
foreach ($gastenboek->getReacties() as $reactie) {
echo 'Naam: '.$reactie->getNaam().'<br />';
echo 'Reactie: '.$reactie->getReactie();
}
?>
Nu mezelf maar aan een database wagen... :)
Verder moet je per bericht een update naar de db doen er een bericht bij plaatsen en in de constructor van Gastenboek moet je alle berichten ophalen uit de db en plaatsen in $_reacties. Hierdoor heb je alle berichten al.
Ik probeer een error af te vangen, maar dit lukt geloof ik niet helemaal. Ook wordt er geen record ingevoegd, dus het gaat fout, maar ik krijg geen exception.
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
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
<?php
class Gastenboek {
private $_db, $_reacties = array();
public function __construct(PDO $connectie) {
$this->_db = $connectie;
}
public function getReacties() {
return $this->_reacties;
}
public function plaatsReactie(Reactie $reactie) {
$query = "INSERT INTO gastenboek (naam, reactie, ip) VALUES (:naam, :reactie)";
$statement = $this->_db->prepare($query);
$statement->bindParam(':naam', $reactie->getNaam(), PDO::PARAM_STR);
$statement->bindParam(':reactie', $reactie->getReactie(), PDO::PARAM_STR);
$statement->execute();
}
}
class Reactie {
private $_naam, $_reactie;
public function __construct($naam, $reactie) {
$this->_naam = $naam;
$this->_reactie = $reactie;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
}
try {
$database = new PDO('mysql:host=localhost;dbname=gastenboek', 'root', '');
$gastenboek = new Gastenboek($database);
$gastenboek->plaatsReactie(new Reactie('Roel', 'Voorbeeld'));
} catch (PDOException $e) {
echo 'Fout: '.$e->getMessage();
}
foreach ($gastenboek->getReacties() as $reactie) {
echo 'Naam: '.$reactie->getNaam().'<br />';
echo 'Reactie: '.$reactie->getReactie();
}
?>
class Gastenboek {
private $_db, $_reacties = array();
public function __construct(PDO $connectie) {
$this->_db = $connectie;
}
public function getReacties() {
return $this->_reacties;
}
public function plaatsReactie(Reactie $reactie) {
$query = "INSERT INTO gastenboek (naam, reactie, ip) VALUES (:naam, :reactie)";
$statement = $this->_db->prepare($query);
$statement->bindParam(':naam', $reactie->getNaam(), PDO::PARAM_STR);
$statement->bindParam(':reactie', $reactie->getReactie(), PDO::PARAM_STR);
$statement->execute();
}
}
class Reactie {
private $_naam, $_reactie;
public function __construct($naam, $reactie) {
$this->_naam = $naam;
$this->_reactie = $reactie;
}
public function getNaam() {
return $this->_naam;
}
public function getReactie() {
return $this->_reactie;
}
}
try {
$database = new PDO('mysql:host=localhost;dbname=gastenboek', 'root', '');
$gastenboek = new Gastenboek($database);
$gastenboek->plaatsReactie(new Reactie('Roel', 'Voorbeeld'));
} catch (PDOException $e) {
echo 'Fout: '.$e->getMessage();
}
foreach ($gastenboek->getReacties() as $reactie) {
echo 'Naam: '.$reactie->getNaam().'<br />';
echo 'Reactie: '.$reactie->getReactie();
}
?>
Tevens moet je met PDO setAttribute() gebruiken om met exceptions te werken (wat wel is aan te raden):
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
try
{
$db = new PDO('mysql:host=localhost;dbname=naam', 'user', 'pass');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$guestbook = new Gastenboek( $db );
}
catch( Exception $e )
{
if( $e instanceof PDOException )
{
echo 'Error with DB: '.$e->getMessage();
}
else
{
echo 'Error: '.$e->getMessage();
}
}
?>
try
{
$db = new PDO('mysql:host=localhost;dbname=naam', 'user', 'pass');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$guestbook = new Gastenboek( $db );
}
catch( Exception $e )
{
if( $e instanceof PDOException )
{
echo 'Error with DB: '.$e->getMessage();
}
else
{
echo 'Error: '.$e->getMessage();
}
}
?>
In je query hebt je nog ip vergeten weg te halen. En je slaat nergens de gegevens op in $_reacties. Dit is hoe ik het zou doen:
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 Guestbook
{
protected $reactions = array();
protected $_db;
public function __construct( PDO $db )
{
$this->_db = $db;
// De select query
$sQuery = "SELECT user, content FROM guestbook";
$stmt = $this->_db->prepare($sQuery);
$stmt->execute();
while( $row = $stmt->fetch(PDO::FETCH_ASSOC) )
{
$this->reactions = new Reaction( $row['user'], $row['content'] );
}
}
public function addReaction( Reaction $reaction )
{
$iQuery = "INSERT INTO guestbook ( user, content ) VALUES ( :name, :content )";
$stmt = $this->_db->prepare($iQuery);
$stmt->execute(Array(
':name', $reaction->getName(),
':content', $reaction->getContent()
));
$this->reactions = $reaction;
}
public function getReactions()
{
return $this->reactions;
}
}
class Reaction
{
protected $user;
protected $content;
public function __construct( $user, $content )
{
$this->user = (string) $user;
$this->content = (string) $content;
}
public function getName()
{
return $this->user;
}
public function getContent()
{
return $this->content;
}
}
?>
class Guestbook
{
protected $reactions = array();
protected $_db;
public function __construct( PDO $db )
{
$this->_db = $db;
// De select query
$sQuery = "SELECT user, content FROM guestbook";
$stmt = $this->_db->prepare($sQuery);
$stmt->execute();
while( $row = $stmt->fetch(PDO::FETCH_ASSOC) )
{
$this->reactions = new Reaction( $row['user'], $row['content'] );
}
}
public function addReaction( Reaction $reaction )
{
$iQuery = "INSERT INTO guestbook ( user, content ) VALUES ( :name, :content )";
$stmt = $this->_db->prepare($iQuery);
$stmt->execute(Array(
':name', $reaction->getName(),
':content', $reaction->getContent()
));
$this->reactions = $reaction;
}
public function getReactions()
{
return $this->reactions;
}
}
class Reaction
{
protected $user;
protected $content;
public function __construct( $user, $content )
{
$this->user = (string) $user;
$this->content = (string) $content;
}
public function getName()
{
return $this->user;
}
public function getContent()
{
return $this->content;
}
}
?>
Waarom gebruik je overigens type cast? Ik snap nog steeds niet wanneer dat handig is in PHP, aangezien ze geen onderscheid maken tussen datatypes.
Roel van de Water:
Waarom gebruik je overigens type cast? Ik snap nog steeds niet wanneer dat handig is in PHP, aangezien ze geen onderscheid maken tussen datatypes.
Omdat ik vanuit C# gewent ben om altijd types mee te geven aan variabelen. En ik wil zeker zijn dat het geen er in de properties zit ook echt is wat ik wil dat erin zit.
Ik ben vergeten weer te geven hoe je die classes nou gebruikt:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
try
{
$pdo = new PDO('mysql:host=localhost;dbname=tabelnaam', 'user', 'pass');
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$guestbook = new Guestbook($pdo);
foreach( $guestbook->getReactions() as $reaction )
{
echo '<h4>'.$reaction->getName().'</h4><p>'.$reaction->getContent().'</p>';
}
if( reactie_toevoegen )
{
$guestbook->addReaction( new Reaction( $_POST['name'], $_POST['content'] ) );
}
}
catch(Exception $e)
{
// Doe wat leuks.
}[/code]
try
{
$pdo = new PDO('mysql:host=localhost;dbname=tabelnaam', 'user', 'pass');
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$guestbook = new Guestbook($pdo);
foreach( $guestbook->getReactions() as $reaction )
{
echo '<h4>'.$reaction->getName().'</h4><p>'.$reaction->getContent().'</p>';
}
if( reactie_toevoegen )
{
$guestbook->addReaction( new Reaction( $_POST['name'], $_POST['content'] ) );
}
}
catch(Exception $e)
{
// Doe wat leuks.
}[/code]
Gewijzigd op 08/01/2012 21:10:46 door Wouter J
Een hele rotzooi.
Wat soms ook gedaan word is, wanneer je een functie aanroept welke de database nodig heeft, de database object word opgehaald via singleton.
Dit resulteert is schonere objecten. Daarnaast kun je geen resources serializen. Mocht je dit object dus wel willen serializen, dan moet je daarvoor weer een fix voor in bouwen.
Synaps Framework op 08/01/2012 20:54:05:
1 vraag: Waarom het database object parsen via de constructor en opslaan in een property? Sinds wanneer is het database object onderdeel van een gastenboek?
Dit gastenboek is onlosmakelijk gekoppeld met die database-verbinding. Netter zou zijn om het opslaan van de berichten weer in een ander object af te handelen, maar je moet ergens stoppen met abstraheren :) (In zo'n geval zou je een Reactie-object hebben dat een reactie beschrijft, een Gastenboek-object dat de regels van een gastenboek beschrijft, en een Reactie-store dat de reacties voor het gastenboek opslaat op een of andere manier. Dan kan je de methode van opslaan veranderen zonder je Reactie- of Gastenboek-class te veranderen. Je hoeft alleen maar een andere store mee te geven.)
Quote:
Mocht je dit object dus wel willen serializen, dan moet je daarvoor weer een fix voor in bouwen.
En dat heb je dan ook meteen goed afgevangen. Met een magic method zorg je er dan voor dat je alleen de array met reacties serialized. Hoe je dan weer een werkend en verbonden gastenboek terugkrijgt wanneer je het unserialized, ik vraag me af of je dat moet willen. Grote kans dat dingen out-of-sync raken als je dit soort dingen gaat doen.
Quote:
Wat soms ook gedaan word is, wanneer je een functie aanroept welke de database nodig heeft, de database object word opgehaald via singleton.
Singletons zorgen juist voor nog hardere koppelingen. Twee gastenboeken naast elkaar op verschillende databases kan je dan niet. Of heel ranzig. Singletons zou ik juist ten alle tijden proberen te vermijden. Die zijn net zo erg als globale variabelen. Wat zeg ik, het zijn globale variabelen, maar dan met een klein beetje meer controle vanuit de singelton zelf. Niet vanuit de gebruikende class, dat is het hele probleem. Geen idee welke andere class m'n singleton object zit aan te passen terwijl ik het gebruik. Brr. Leuk voorbeeld: een singelton database-verbinding en transacties.
Jelmer rrrr op 08/01/2012 23:40:25:
Dit gastenboek is onlosmakelijk gekoppeld met die database-verbinding. Netter zou zijn om het opslaan van de berichten weer in een ander object af te handelen, maar je moet ergens stoppen met abstraheren :) (In zo'n geval zou je een Reactie-object hebben dat een reactie beschrijft, een Gastenboek-object dat de regels van een gastenboek beschrijft, en een Reactie-store dat de reacties voor het gastenboek opslaat op een of andere manier. Dan kan je de methode van opslaan veranderen zonder je Reactie- of Gastenboek-class te veranderen. Je hoeft alleen maar een andere store mee te geven.)
En dat heb je dan ook meteen goed afgevangen. Met een magic method zorg je er dan voor dat je alleen de array met reacties serialized. Hoe je dan weer een werkend en verbonden gastenboek terugkrijgt wanneer je het unserialized, ik vraag me af of je dat moet willen. Grote kans dat dingen out-of-sync raken als je dit soort dingen gaat doen.
Singletons zorgen juist voor nog hardere koppelingen. Twee gastenboeken naast elkaar op verschillende databases kan je dan niet. Of heel ranzig. Singletons zou ik juist ten alle tijden proberen te vermijden. Die zijn net zo erg als globale variabelen. Wat zeg ik, het zijn globale variabelen, maar dan met een klein beetje meer controle vanuit de singelton zelf. Niet vanuit de gebruikende class, dat is het hele probleem. Geen idee welke andere class m'n singleton object zit aan te passen terwijl ik het gebruik. Brr. Leuk voorbeeld: een singelton database-verbinding en transacties.
Synaps Framework op 08/01/2012 20:54:05:
1 vraag: Waarom het database object parsen via de constructor en opslaan in een property? Sinds wanneer is het database object onderdeel van een gastenboek?
Dit gastenboek is onlosmakelijk gekoppeld met die database-verbinding. Netter zou zijn om het opslaan van de berichten weer in een ander object af te handelen, maar je moet ergens stoppen met abstraheren :) (In zo'n geval zou je een Reactie-object hebben dat een reactie beschrijft, een Gastenboek-object dat de regels van een gastenboek beschrijft, en een Reactie-store dat de reacties voor het gastenboek opslaat op een of andere manier. Dan kan je de methode van opslaan veranderen zonder je Reactie- of Gastenboek-class te veranderen. Je hoeft alleen maar een andere store mee te geven.)
Quote:
Mocht je dit object dus wel willen serializen, dan moet je daarvoor weer een fix voor in bouwen.
En dat heb je dan ook meteen goed afgevangen. Met een magic method zorg je er dan voor dat je alleen de array met reacties serialized. Hoe je dan weer een werkend en verbonden gastenboek terugkrijgt wanneer je het unserialized, ik vraag me af of je dat moet willen. Grote kans dat dingen out-of-sync raken als je dit soort dingen gaat doen.
Quote:
Wat soms ook gedaan word is, wanneer je een functie aanroept welke de database nodig heeft, de database object word opgehaald via singleton.
Singletons zorgen juist voor nog hardere koppelingen. Twee gastenboeken naast elkaar op verschillende databases kan je dan niet. Of heel ranzig. Singletons zou ik juist ten alle tijden proberen te vermijden. Die zijn net zo erg als globale variabelen. Wat zeg ik, het zijn globale variabelen, maar dan met een klein beetje meer controle vanuit de singelton zelf. Niet vanuit de gebruikende class, dat is het hele probleem. Geen idee welke andere class m'n singleton object zit aan te passen terwijl ik het gebruik. Brr. Leuk voorbeeld: een singelton database-verbinding en transacties.
Singleton is zeker niet de oplossing. Wellicht kan de TS eens kijken naar de DI van Symfony? Vind het storen van een geheel DB object in je property echter een no-go.
Neemt niet weg dat TS hier geheel anders over denkt, het is puur mijn mening. Doe er dus mee wat je wilt ;).
Toevoeging op 09/01/2012 10:03:54:
Roel van de Water op 08/01/2012 17:50:29:
Daarnaast, mocht je dit graag willen, dan zou je eens kunnen kijken naar ArrayObject of Iterator.
Gr.
Gewijzigd op 09/01/2012 10:06:30 door Synaps Framework
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
$_POST['name'] = 'Bob';
$_POST['content'] = 'Hallo!';
// Er wordt een reactie toegevoegd:
if( reactie_toevoegen )
{
//Stuur je hier nou een Class Reaction mee, zodat je de get title en content
//kan gebruiken?
$guestbook->addReaction( new Reaction( $_POST['name'], $_POST['content'] ) );
}
?>
$_POST['name'] = 'Bob';
$_POST['content'] = 'Hallo!';
// Er wordt een reactie toegevoegd:
if( reactie_toevoegen )
{
//Stuur je hier nou een Class Reaction mee, zodat je de get title en content
//kan gebruiken?
$guestbook->addReaction( new Reaction( $_POST['name'], $_POST['content'] ) );
}
?>
Hier wordt het bericht afgehandeld
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
// Je geeft hier class reaction dus mee
public function addReaction( Reaction $reaction )
{
//query
$iQuery = "INSERT INTO guestbook ( user, content ) VALUES ( :name, :content )";
//prepare
$stmt = $this->_db->prepare($iQuery);
//execute
$stmt->execute(Array(
//Deze kan je dus ophalen omdat je de class hebt meegegeven gok ik
':name', $reaction->getName(),
':content', $reaction->getContent()
));
//En dan vraag ik me af wat hier nog gebeurt, zet je hier nou de extra
//waardes (Bob, Hallo!) in de array die je tijdens de construct al hebt
//opgebouwd vanuit je database?
$this->reactions = $reaction;
}
?>
// Je geeft hier class reaction dus mee
public function addReaction( Reaction $reaction )
{
//query
$iQuery = "INSERT INTO guestbook ( user, content ) VALUES ( :name, :content )";
//prepare
$stmt = $this->_db->prepare($iQuery);
//execute
$stmt->execute(Array(
//Deze kan je dus ophalen omdat je de class hebt meegegeven gok ik
':name', $reaction->getName(),
':content', $reaction->getContent()
));
//En dan vraag ik me af wat hier nog gebeurt, zet je hier nou de extra
//waardes (Bob, Hallo!) in de array die je tijdens de construct al hebt
//opgebouwd vanuit je database?
$this->reactions = $reaction;
}
?>
Gewijzigd op 22/02/2012 14:45:11 door gerhard l
Je wilt een reactie toevoegen aan een gastenboek. Allebei de onderstreepte woorden zijn objecten en dienen dus een eigen class te hebben. Als je 1 object aan het andere object toevoegt, in dit geval dus een reactie aan het gastenboek, moet je ook de ene class toevoegen aan de andere.
Verder moet je niet denken, 'ik geef de reaction class mee omdat ik later functies daarvan nodig heb in de afhandeling van de method', maar je moet denken dat je het mee geeft omdat je 1 object aan het andere toevoegt. Objecten moet je apart van elkaar gebruiken. De reaction hoeft niet te weten dat hij gebruikt wordt in een gastenboek en het gastenboek hoeft niet te weten hoe de reaction class eruit ziet. Hij moet alleen zeker weten dat de reaction class 2 methods heeft: getName en getContent.
>> Je geeft hier class reaction dus mee
Nee, het meegeven doe je in het code blok ervoor. Op deze regel geef je aan dat je als parameter van de addReaction method een Reaction object verwacht. Als je iets anders meegeeft krijg je een error.
>> Deze kan je dus ophalen omdat je de class hebt meegegeven gok ik
Ja, $reaction bevat de class Reaction en dus kun je alles gebruiken wat je wilt van die Reaction klasse.
>> En dan vraag ik me af wat hier nog gebeurt, zet je hier nou de extra waardes (Bob, Hallo!) in de array die je tijdens de construct al hebt opgebouwd vanuit je database?
Allereerst zie ik dat er een foutje staat, het moet $this->reactions[] = $reaction zijn. Mijn excusses...
Maar om op je vraag te komen. Met deze functie voegen we de nieuwe Reaction object toe aan onze array met alle reacties van dit gastenboek. Het voordeel hiervan is dat we met Gastenboek::getReactions() gewoon meteen de array reactions kunnen returnen, i.p.v. eerst een DB query uit te voeren.
Tevens kun je vanuit OO oogpunt zeggen dat de reactions een eigenschap, en dus een propertie, is van het object Gastenboek.