Starten met OOP.
Quote:
class GASTENBOEK
- reacties ophalen
- reacties deleten waar het id == $id
- reacties ophalen
- reacties deleten waar het id == $id
Bingo.
Quote:
class REACTIE
- id van reactie ophalen
- auteur van reactie ophalen
- inhoud van reactie ophalen
- id van reactie ophalen
- auteur van reactie ophalen
- inhoud van reactie ophalen
Niet helemaal. De Reactie bewaart, bevat, heeft een id, een auteur en een inhoud. Ophalen doet de gastenboek class, die haalt immers de reacties op (en deze drie dingen zijn eigenschappen van een reactie, onderdeel van die reactie.)
Quote:
ONTBREEKT
-naam auteur onthouden
- een reactie onthouden
-naam auteur onthouden
- een reactie onthouden
Naam auteur zit in de reactie, of in het User-object waar de auteur van een reactie naar verwijst. Ligt eraan hoe diep je wilt gaan. Reacties worden opgehaald door Gastenboek, voor nu is het ook prima om ze daar maar mee op te slaan.
Implementeren is nu heel gemakkelijk. Nu zou ik moeten zeggen van probeer het maar eens.
Spoiler Alert
Gewijzigd op 28/12/2010 00:37:11 door Jelmer -
OOP vraagje. Stel dat je een login/register systeem hebt. Je hebt een class User. Kan een User zichzelf registreren? Ik bedoel: moet je een method 'register' opnemen in de User class?
Dat is eigenlijk altijd al een vraag geweest, en iedereen z'n antwoord is anders.
Als jij een User als puur object gebruikt, dan kan hij inderdaad niet bij de database.
Want een User heeft ook geen database toegang in je Object, en je UserController heeft dat waarschijnlijk wel.
Wat je ook wel ziet is dat een User wel database toegang heeft, daarbij zie je ook vaak dingen als:
$user = new User(id);
$user->save();
En dan pakt hij automatisch de juiste user.
En slaat hij de user op.
Zelf doe ik het altijd met een UserController en een AuthentificationController (voor het in en uitloggen).
En dan krijg je dingen als:
$userController->save($user);
Ik maak me code vaak zo dat hij in de save functie gaat kijken of het een nieuwe user is, of een oude, en dan roep ik de bijbehorende private functie aan.
Om fouten op te vangen bij registraties werk ik altijd met een setVar(var), en die gooit exceptions op als er een foute input is.
Maar wat denk jij zelf dat het beste werkt, en wat zou jij het lekkerste vinden werken?
Ben zelf ook (net als PHP Jasper) bezig om OOP onder de knie te krijgen en toen kwam deze vraag boven drijven.
Om antwoord te geven op jouw vraag:
Als je dan toch OOP bezig bent, dan maar meteen goed. Dus: UserController. Al zou ik wel graag van jou horen wat je precies bedoelt met: "Ik maak me code vaak zo dat hij in de save functie gaat kijken of het een nieuwe user is, of een oude, en dan roep ik de bijbehorende private functie aan." Dat snap ik namelijk niet helemaal.
Het is natuurlijk wel lekker makkelijk om gewoon een save/register-methode op te nemen in de User class, maar strict genomen klopt het - naar mijn idee - natuurlijk niet.
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
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
User_Store
- create($nickname, $email)
- get($id)
User
- id()
// regelt het onthouden van iemands identiteit (in bijv. $_SESSION)
Authentication
- __construct(User_Store $users)
// roept $method->login($arguments) aan, en onthoudt het user-id dat die teruggeeft
- login(AuthenticationMethod $method, array $arguments)
- isLoggedIn()
// geeft $users->get($currentUserId) terug.
- currentUser()
PasswordIdentification extends AuthenticationMethod
// koppelt een gebruiker aan een wachtwoord
- register(User $user, $password)
// geeft user-id terug indien gelukt
- login(array $arguments)
OpenIDIdentification extends AuthentictionMethod
- register(User $user, $openid)
// geeft user-id terug indien gelukt
- login(array $arguments)
- create($nickname, $email)
- get($id)
User
- id()
// regelt het onthouden van iemands identiteit (in bijv. $_SESSION)
Authentication
- __construct(User_Store $users)
// roept $method->login($arguments) aan, en onthoudt het user-id dat die teruggeeft
- login(AuthenticationMethod $method, array $arguments)
- isLoggedIn()
// geeft $users->get($currentUserId) terug.
- currentUser()
PasswordIdentification extends AuthenticationMethod
// koppelt een gebruiker aan een wachtwoord
- register(User $user, $password)
// geeft user-id terug indien gelukt
- login(array $arguments)
OpenIDIdentification extends AuthentictionMethod
- register(User $user, $openid)
// geeft user-id terug indien gelukt
- login(array $arguments)
Maar in veel gevallen is dat misschien wat teveel, en dan zou ik zeggen dat je User_Store::create een extra argument, $password, meegeeft, en een extra method, User_Store::login($username, $password) die dan net zo werkt als User_Store::get($id), en dat je zelf de sessies e.d. afhandelt in een simpele class.
Bedankt voor de reactie. Ik ben bezig met het maken van een user/login script. Ik zal het later vandaag eens plaatsen (als ik er ver genoeg mee kom) zodat je het eventueel van commentaar kunt voorzien?
Wat ik mij nu afvraag: Ik zie jou overal het volgende doen:
"register(User $user, $password)"
"__construct(User_Store $users)"
Je geeft aan de methods iets mee dat geen variabele is. Kun je mij uitleggen wat dat precies is en waarom je dit doet? Dus: "(User" en (User_Store".
Gewijzigd op 28/12/2010 10:27:58 door The Ultimate
Wat op zich niet erg is, maar OO denken is op 1001 manieren mogelijk.
De manier van een save methode in een User object is in mijn optiek ook niet correct OO, maar ik heb me door ervaren rotten op het gebied laten vertellen dat dat het wel is, maar iedereen z'n eigen smaak.
Een user Id is bij mij altijd standaard null.
Als ik de user ophaal, dan zorg ik dat hij de id zet op het bijbehorende id.
Dan krijg ik na een registratie of update altijd de regel:
$userController->save($user);
mijn save methode is dan eigenlijk heel simpel.
Code (php)
Dan hoef je dus niet meer na te denken over exacte afhandeling, als je hetzelfde doel wilt (iets vernieuwen of bijzetten in de db) bereiken, kan je ervoor kiezen om de keuze voor Insert of Update te laten bepalen door je Controller.
Als ik het goed begrijp dan registreer jij dus ook iedereen die per ongeluk een verkeerd e-mailadres ingeeft (bijv. 1 letter verkeerd)?
@Jelmer:
Zie mijn vorige reactie.
Gewijzigd op 28/12/2010 10:36:07 door The Ultimate
Ik snap jou reactie niet helemaal, waarom zou je niet iemand willen registreren die een verkeerd mail adres invult, je weet toch nooit of het e-mail adres correct is?
Nicoow Unknown op 28/12/2010 10:39:34:
Alleen als je 1 en hetzelfde formulier gebruikt voor login en register. Ik laat bestaande gebruikers niet inloggen op mijn registratie-formulier. Dan weet ik dus al of iemand zich wil registreren of inloggen en daarop reageer je door of de gebruiker te registreren of in te loggen. Dat hoeft mijn script niet uit te zoeken. Lijkt me wel zo duidelijk.Tuurlijk registreer je iemand die een verkeerd e-mail adres ingeeft
Kan zijn dat ik er helemaal naast zit hoor. Ben maar een amateur, dus hoor het graag als het anders is.
Wie laat nou iemand inloggen op een registratie formulier?
Bij mij is het gewoon luiheid dat ik save() gebruik, en die 1 keer implementeer.
En dat ik er niet voor kies iedere keer zelf moet gaan kijken of het een update is of een registratie.
Dit kan dan namelijk een stuk makkelijker zijn op het moment dat je classes gaat gebruiken om formulieren naar voren te toveren, maar dat komt nog wel een keer ;)
Code (php)
@ jelmer, moet er bij dit stuk bij $db niet de host/gebruikersnaam/wachtwoord/database?
edit:
Code (php)
kan je i.d.p.v. new DateTime() niet gebruik maken van de mysql_functie NOW() of gaat dat niet met pdo
Gewijzigd op 28/12/2010 12:16:21 door Jasper DS
The Ultimate op 28/12/2010 10:27:34:
Wat ik mij nu afvraag: Ik zie jou overal het volgende doen:
"register(User $user, $password)"
"__construct(User_Store $users)"
Je geeft aan de methods iets mee dat geen variabele is. Kun je mij uitleggen wat dat precies is en waarom je dit doet? Dus: "(User" en (User_Store".
"register(User $user, $password)"
"__construct(User_Store $users)"
Je geeft aan de methods iets mee dat geen variabele is. Kun je mij uitleggen wat dat precies is en waarom je dit doet? Dus: "(User" en (User_Store".
Ik geef aan van wat voor class $user een instantie moet zijn. Zo kan je bij register($user, $password) aan $user alleen maar een instantie van de class User meegeven.
PHP Jasper op 28/12/2010 12:11:50:
@ jelmer, moet er bij dit stuk bij $db niet de host/gebruikersnaam/wachtwoord/database?
$db is een instantie van Database, en Database is gemaakt met een instantie van PDO, en die instantie van PDO is gemaakt met m'n gebruikersnaam/wachtwoord/pad-naar-sqlite-database.
PHP Jasper op 28/12/2010 12:11:50:
kan je i.d.p.v. new DateTime() niet gebruik maken van de mysql_functie NOW() of gaat dat niet met pdo
Kan ook, maar in mijn voorbeeld met die Database class zou 'NOW()' die quote-stap niet overleven, en letterlijk als de tekst NOW() worden geïnterpreteerd. En aangezien ik graag DateTime objecten gebruik, leek dit me even een gemakkelijke oplossing. Meestal gebruik ik een Database class achtig ding dat ook gewoon rauwe SQL aankan, en dan zou je NOW() kunnen gebruiken.
Nicoow Unknown op 28/12/2010 10:27:42:
De manier van een save methode in een User object is in mijn optiek ook niet correct OO, maar ik heb me door ervaren rotten op het gebied laten vertellen dat dat het wel is, maar iedereen z'n eigen smaak.
Het is inderdaad smaak, maar ik probeer zelf altijd ervoor te zorgen dat als je een object hebt, dat het object ook compleet en correct, en meteen bruikbaar is. Altijd. Value semantics, data hiding oid. Daarom dus geen public properties (want dan kan de class niet de waarden in die variabelen controleren, en kan hij niet garanderen dat het klopt) en daarom ook geen lege new User() aan kunnen maken, want die User is geen echte user, want hij is incompleet. Niet altijd even praktisch, maar volgens mij wel correct. En als je aan het leren bent kan je het het best correct leren, en dan langzaam afglijden naar praktisch lijkt mij.
Gewijzigd op 11/01/2011 19:02:54 door Jasper DS
