[oop] constructor als "uitvoerder"?

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Pagina: 1 2 3 volgende »

Ozzie PHP

Ozzie PHP

18/05/2014 17:09:16
Quote Anchor link
Hi guys,

Een Processor/Core/Kernel class doorloopt allerlei stappen. Mag de consructor deze stappen triggeren/uitvoeren? Even een heeeeel erg versimpeld voorbeeldje met 3 fictieve functies.

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
<?php

class Processor {

  private $request;

  public function __constructor($request) {
    $this->request = $request.
    $this->initializeRequest();
    $this->executeRequest();
    $this->sendResponse();
  }

}

?>

Zou de constructor deze functies mogen triggeren? Is dat oké volgens het OOP principe?
 
PHP hulp

PHP hulp

25/12/2024 08:24:36
 
D Vivendi

D Vivendi

18/05/2014 17:26:33
Quote Anchor link
Ja tuurlijk, waarom zou dat niet mogen?

De vraag is meer of het handig is. En dat kan jij alleen beantwoorden. Als jij denkt dat het handig is dat die class direct methods etc aanroept op het moment dat jij daar een instantie van aanmaakt, dan is dat goed.

Ik zou overigen wel aan type hinting doen wanneer dat kan, Dus:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
Public function __construct ( IRequest $request ) { }


Dan weet je zeker dat het object dat jij binnen krijgt beschikt over bepaalde methods.
Gewijzigd op 18/05/2014 17:28:23 door D Vivendi
 
Ozzie PHP

Ozzie PHP

18/05/2014 17:31:45
Quote Anchor link
Die typehinting doe ik ook ;) Dit was slechts een voorbeeldje.

Oké... ik vroeg me dus af of zoiets oké is, omdat de constructor dan het hele proces "aanstuurt".

Je zou bijvoorbeeld ook dit kunnen doen:

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
<?php

class Processor {

  private $request;

  public function __constructor($request) {
    $this->request = $request.
    $this->execute();
  }

  private function execute() {
    $this->initializeRequest();
    $this->executeRequest();
    $this->sendResponse();
  }

}

?>

Nu stuurt de "execute" method alles aan, maar volgens mij is dit eigenlijk een "schijn"-constructie omdat de "execute" method alsnog door de constructor wordt aangeroepen en het in feite dus een verlengstuk van de constructor is. Mee eens?
Gewijzigd op 18/05/2014 17:32:25 door Ozzie PHP
 
D Vivendi

D Vivendi

18/05/2014 17:41:11
Quote Anchor link
Oneens. Het kan wel handig zijn om private methods aan te roepen vanuit je constructor. Maar alleen zodat je niet veel logica in een constructor hoef te hebben. Stukken logica verhuis je dan naar methods die je een goed omschrijvende naam geeft.

Ik dacht dat je het eerst over public methods had.
 
Ozzie PHP

Ozzie PHP

18/05/2014 17:49:33
Quote Anchor link
Nu volg ik je even niet meer. Ben je het nu wel of niet eens om die methods vanuit de constructor aan te roepen? Het gaat om private methods.
 
Frank Nietbelangrijk

Frank Nietbelangrijk

18/05/2014 17:54:01
Quote Anchor link
Wat je goed moet begrijpen Ozzie is dat alles wat de constructor doet je niet meer kunt onderbreken als je een nieuwe instantie van de class aanmaakt. Als je later de class gaat gebruiken en je wil na het instantiëren nog een property van het object wijzigen dan heeft je constructor al een aantal stappen doorlopen eer jij de kans krijgt deze property te wijzigen. Dat kan soms onhandig zijn. Daarnaast is het zo dat een constructor niets kan return-en. Ook dat is in sommige gevallen niet handig en zou bij mij reden zijn om een nieuwe method aan te maken. Ik zie die constructor eigenlijk als een methode om de class-properties te initialiseren. Wat mij betreft hoort dus alleen $this->initializeRequest(); in de constructor thuis.

D Vivendi op 18/05/2014 17:41:11:
Oneens. Het kan wel handig zijn om private methods aan te roepen vanuit je constructor. Maar alleen zodat je niet veel logica in een constructor hoef te hebben. Stukken logica verhuis je dan naar methods die je een goed omschrijvende naam geeft.

Ik dacht dat je het eerst over public methods had.


Private of public heeft hier niets mee te maken. Het mag beiden vanuit de constructor.


Toevoeging op 18/05/2014 18:00:15:

Ozzie PHP op 18/05/2014 17:31:45:
Nu stuurt de "execute" method alles aan, maar volgens mij is dit eigenlijk een "schijn"-constructie omdat de "execute" method alsnog door de constructor wordt aangeroepen en het in feite dus een verlengstuk van de constructor is. Mee eens?


Ja en Nee. die execute method kan ook later nog worden aangeroepen vanuit een andere method. Hierdoor is het geen verlengstuk meer van de constructor. Wanneer er echt geen reden valt te bedenken onder welke omstandigheden deze functie later nog eens aangeroepen zou kunnen worden dan is het inderdaad niets meer dan een verlengstuk van de constructor maar als dat dan de leesbaarheid van de code verbeterd ben ik een voorstander om het alsnog te gebruiken. Uiteraard moeten de namen van je methods zo goed mogelijk omschrijven wat de taak is van de method zoals D Vivendi opmerkt.
 
Ozzie PHP

Ozzie PHP

18/05/2014 18:00:17
Quote Anchor link
Dankjewel voor je reactie Frank. Het is ook niet de bedoeling dat er na het instantiëren van het object er nog iets mee gebeurt. Dus op zich klopt dat wel.

>> Wat mij betreft hoort dus alleen $this->initializeRequest(); in de constructor thuis.

Oké... maar ik wil dus niet handmatig de "executeRequest" method aanroepen, die moet dus ergens door worden aangeroepen. In de constructor zelf? Of de constructor een soort van "execute" method laten aanroepen die vervolgens alle methods aanroept? Volgens mij schiet ik daar eigenlijk weinig mee op.
 
Frank Nietbelangrijk

Frank Nietbelangrijk

18/05/2014 18:02:47
Quote Anchor link
Ehm ik had nog wat toegevoegd Ozzie, en als jij zegt dat die handelingen in ieder voorkomende situatie direct uitgevoerd kunnen worden dan mag dat dus gewoon.
 
Ozzie PHP

Ozzie PHP

18/05/2014 18:18:32
Quote Anchor link
Oke... maar in principe als aan de "voorwaarden" die jij noemt is voldaan, dan kan zo'n constructie als dit dus gewoon prima? :)

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
<?php

class Foo {

  private $foo;
 
  public function __constructor($foo, $bar) {
    $this->foo= $foo.
    $this->initializeFoo();
    $this->executeFoo();
    $this->doTheFoo();
    $this->addSomeBar($bar);
    $this->createFooBar();
  }

}

?>
 
Frank Nietbelangrijk

Frank Nietbelangrijk

18/05/2014 19:28:00
Quote Anchor link
Jep
 
Ozzie PHP

Ozzie PHP

18/05/2014 20:01:19
Quote Anchor link
Allrightie... thanks :)
 
Dos Moonen

Dos Moonen

18/05/2014 20:21:11
Quote Anchor link
Wauw, wat is dat lelijk!

Misschien nog eens nalezen wat het doel van een constructor is?
 
Ozzie PHP

Ozzie PHP

18/05/2014 20:43:09
Quote Anchor link
>> Wauw, wat is dat lelijk!

Kun je ook uitleggen waarom Dos? Ik roep geen enkele functie van buiten de class aan. Dus alles moet vanuit de class zelf worden gestart. Hoe kan ik dat dan volgens jou het beste doen?

Ik vind het leuk dat je reageert... maar het is dan ook wel handig als je aangeeft hoe het volgens jou dan wel moet :-)
 
Wouter J

Wouter J

18/05/2014 20:45:32
Quote Anchor link
>> Ik vind het leuk dat je reageert... maar het is dan ook wel handig als je aangeeft hoe het volgens jou dan wel moet :-)


Dos Moonen:
Misschien nog eens nalezen wat het doel van een constructor is?


Heb je dat al gedaan?
 
Dos Moonen

Dos Moonen

18/05/2014 20:48:21
Quote Anchor link
Een constructor moet een object gebruiksklaar maken. Die constructor van jou doet veel meer.

Een optie is om de constructor private te maken en het meeste van wat nu in de constructor gebeurt verplaatsen naar een public static method.
 
Wouter J

Wouter J

18/05/2014 20:50:20
Quote Anchor link
Dos: ook dat is niet mooi. Een static method die en class aanmaakt is een factory en niks anders en het enige wat een factory mag doen is het aanmaken van een object (die vervolgens zichzelf gebruiksklaar maakt).

Je moet dit soort dingen gewoon nooit bij aanmaken doen :)
 
Ozzie PHP

Ozzie PHP

18/05/2014 20:51:20
Quote Anchor link
@Wouter:

Ik weet wat het doel is. En daar stelde ik dus een vraag over:

Ozzie PHP op 18/05/2014 17:09:16:
Zou de constructor deze functies mogen triggeren? Is dat oké volgens het OOP principe?

Volgens Frank mag ik dat doen. Volgens Dos niet?

Wat is dan volgens Dos wél de juiste manier?

@Dos:

>> Een optie is om de constructor private te maken en het meeste van wat nu in de constructor gebeurt verplaatsen naar een public static method.

Wat is dan het wezenlijke verschil als ik vragen mag? En waarom een static method?

Toevoeging op 18/05/2014 20:52:12:

>> Je moet dit soort dingen gewoon nooit bij aanmaken doen :)

Maar dan moet ik het handmatig triggeren dus?
 
Wouter J

Wouter J

18/05/2014 20:53:29
Quote Anchor link
>> En waarom een static method?

Omdat je een object met private constructor niet kunt aanmaken.

>> Maar dan moet ik het handmatig triggeren dus?

Ja, erg hè? :P
 
Ozzie PHP

Ozzie PHP

18/05/2014 21:12:51
Quote Anchor link
>> Omdat je een object met private constructor niet kunt aanmaken.

Oké... maar net zeg je nog dat ik geen static method moet gebruiken :-s

>> Ja, erg hè? :P

Alle gekheid op een stokje. Het gaat er niet om of het wel of niet erg is.

Waar het om gaat is het volgende. En ik hoop dat je dan even kunt meedenken met me ;)

Het enige wat die class kan doen, is een request afhandelen. Niks meer en niks minder. Ward vertelde ooit op het forum dat als je een bepaalde functie hebt die je altijd aanroept na het initialiseren van een class, dat je dan die functie net zo goed in de constructor kunt stoppen, aangezien de functie blijkbaar altijd moet worden aangeroepen. Goed punt toch? Dus vanuit dat oogpunt zou ik de execute functie vanuit de constructor kunnen aanroepen.

Is dit dan wel oké?

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
<?php

class Processor {

  private $request;

  public function __constructor($request) {
    $this->request = $request.
    $this->execute();
  }

  private function execute() {
    $this->initializeRequest();
    $this->executeRequest();
    $this->sendResponse();
  }

}

?>
 
Wouter J

Wouter J

18/05/2014 21:24:31
Quote Anchor link
Nee, de constructor maakt een object klaar voor gebruik. Niks meer niks minder. Hij voert niks uit, hij doet niks, alleen klaar maken voor gebruik.
Het maakt niks uit als hij het uitvoeren naar een andere functie verplaatst en het vervolgens aanroept. Dan gebeurd het nog steeds tijdens de constructie periode.

Ik zou niet eens die Request meegeven als constructor argument, waarom zou je niet 2 verschillende requesten mogen afhandelen met hetzelfde object?

Nogmaals: Is het erg als je 2 requesten afhandelt? Nee toch? Waarom zou je je dan gaan beperken?
 
Ozzie PHP

Ozzie PHP

18/05/2014 21:41:40
Quote Anchor link
>> Ik zou niet eens die Request meegeven als constructor argument, waarom zou je niet 2 verschillende requesten mogen afhandelen met hetzelfde object?

Omdat je per pagina-aanroep maar 1 request kunt afhandelen.

Maar oké... dus jij zegt: niks aanroepen vanuit de constructor.

Ben jij het dan niet eens met de opmerking van Ward? Dus dat wanneer je altijd dit doet:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
<?php
$core = new Core($request);
$core->execute();
?>

Dat je dan net zo goed die execute method kunt aanroepen vanuit de constructor?
 

Pagina: 1 2 3 volgende »



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.