construct en properties

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Pagina: 1 2 volgende »

Ozzie PHP

Ozzie PHP

02/01/2013 13:25:44
Quote Anchor link
Ola,

Een vraagje over construct i.c.m. properties. Is het de bedoeling dat class properties ALTIJD vanuit de __construct functie worden gedeclareerd? Anders gezegd, als je class properties gebruikt, betekent dit dan automatisch dat je een __construct functie moet maken? Stel dat je wel class properties wilt gebruiken, maar je wil deze in een aparte functie declareren. Moet je ze dan toch eerst via de __construct functie declareren?

Voorbeeld, ik wil een username declareren in de functie setUsername(). Mag het dan zo:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {

  private $username;

  public function setUsername($first_name, $last_name) {
    $username = $first_name . ' ' . $last_name;
    $this->username = username;
  }

}

?>


of moet ik echt perse eerst in de __construct de property $username declareren. Dus zo:

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 User {

  private $username;

  public function __construct() {
    $this->username = '';
  }


  public function setUsername($first_name, $last_name) {
    $username = $first_name . ' ' . $last_name;
    $this->username = username;
  }

}

?>
Gewijzigd op 02/01/2013 13:26:51 door Ozzie PHP
 
PHP hulp

PHP hulp

17/10/2021 14:54:41
 
Wouter J

Wouter J

02/01/2013 13:31:26
Quote Anchor link
Het mooie van PHP is dat niks moet en het bijna altijd meerdere manieren biedt. Ga je alleen naar echte OO talen kijk, dan zie je dat een waarde geven bij het declareren van een property helemaal niet mogelijk is. De OO mannen van dit forum zullen je dus zeer waarschijnlijk aanraden het via een constructor te doen, maar ik niet per se.

Allereerst heeft jou code voorbeeld helemaal geen toegevoegde waarde. Of de username bij default nou '' heeft of null maakt natuurlijk niks uit en ik vind null zelfs mooier.
Als je het hebt over default waardes zet ik die gewoon bij het declareren neer, lekker makkelijk en je houdt je constructor schoon. Bijv:
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
<?php
class Table
{
    private $rows = array();
}

// ipv
class Table
{
    private $rows;

    public function __construct()
    {

        $this->setRows(array());
    }


    public function setRows(array $rows)
    {

        $this->rows = $rows;
    }
}

?>
 
Ozzie PHP

Ozzie PHP

02/01/2013 13:35:25
Quote Anchor link
Nee, dat is dus precies wat ik bedoel... dat leeg declareren dat slaat mijns insziens ook nergens op.
Om mijn voorbeeldje te pakken... jij zou het dan dus zo doen??

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {

  private $username = '';

  public function setUsername($first_name, $last_name) {
    $username = $first_name . ' ' . $last_name;
    $this->username = username;
  }

}

?>
 
Moose -

Moose -

02/01/2013 13:40:38
Quote Anchor link
of gewoon private $username; Ik vind het zelf ook mooier om zoiets niet in de constructor te doen maar echt getters en setters maken. Wanneer je echt zeker weet dat een model altijd dezelfde data verplicht moet hebben kan je het in de constructor meegeven. Bijvoorbeeld een filelezer, dan maak je daar de constructor voor aan waarbij je een file meegeeft. Zo kan je ook afdwingen dat hij altijd een file moet hebben en hoef je dat niet later te checken (if(file == null) exception)
 
Wouter J

Wouter J

02/01/2013 13:43:00
Quote Anchor link
Ozzie, nee. Ik heb dat ooit wel gedaan om aan te geven welke type de variabele heeft:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
<?php
class User
{
    private $name = '';
    private $age = 0;
    private $parents = array();
}

?>


Maar tegenwoordig ben ik daarvan afgestapt en gebruik ik PHPdoc om aan te geven welke type het is, mocht het niet al duidelijk zijn.
 
Ozzie PHP

Ozzie PHP

02/01/2013 13:47:02
Quote Anchor link
Ja, zo heb ik het ook een tijd gedaan:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
<?php
class User
{
    private $name = '';
    private $age = 0;
    private $parents = array();
}

?>


Maar het wordt dan gauw zo'n rommeltje.
Maar als ik het dus zo doe, dan is het ook gewoon goed OOP?

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {

  private $username;

  public function setUsername($first_name, $last_name) {
    $username = $first_name . ' ' . $last_name;
    $this->username = username;
  }

}

?>
 
Wouter J

Wouter J

02/01/2013 13:47:56
Quote Anchor link
ja, niks mis mee en misschien vind ik het ook mooier. Bij het eerste voorbeeld geef je aan dat de default waarde leeg is, maar die property moet helemaal geen default waarde hebben, dat moet gewoon null blijven.
 
Ozzie PHP

Ozzie PHP

02/01/2013 13:51:02
Quote Anchor link
Ik vind het op deze manier ook mooi, maar ik kan me een tijd herinneren dat ik alles in de construct liep te declareren met lege strings en arrays. Allemaal niet heel overzichtelijk en een beetje nutteloze code. Maar dan ga ik het van nu af aan dus zo doen als in het laatste code voorbeeld!
 
- Raoul -

- Raoul -

02/01/2013 14:00:52
Quote Anchor link
Ozzie PHP op 02/01/2013 13:51:02:
alles in de construct liep te declareren met lege strings en arrays


Dat is een beetje raar. Je kunt ook gewoon default parameters kiezen.
Dan kan je kiezen of je je username passed in de constructor of niet, en zoniet kun je nog altijd de username instellen via de setter.

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 User
{
  public $username = null;

  public function __construct($username = null)
  {

    $this->setUsername($username);
  }


  public function setUsername($username)
  {

    $this->username = $username;
  }
}


?>
Gewijzigd op 02/01/2013 14:01:41 door - Raoul -
 
Ozzie PHP

Ozzie PHP

02/01/2013 14:05:38
Quote Anchor link
Ja, maar dit

public $username = null;

is hetzelfde als dit

public $username;

Ik snap wel wat je bedoelt, maar als je dit met elkaar vergelijkt:

1)

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
<?php
class User {

  private $username;

  public function setUsername($first_name, $last_name) {
    $username = $first_name . ' ' . $last_name;
    $this->username = username;
  }

}

?>


2)

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 User
{
  public $username = null;

  public function __construct($username = null)
  {

    $this->setUsername($username);
  }


  public function setUsername($username)
  {

    $this->username = $username;
  }
}


?>


dan is voorbeeld 1 een stuk rustiger. En nu gaat het maar om 1 variabele, maar wat als het er 10 zijn.
 
Ward van der Put
Moderator

Ward van der Put

02/01/2013 14:08:27
Quote Anchor link
Je kunt in de constructor een methode aanroepen. Dat kan handig zijn wanneer je, zoals hier, een veelgebruikte setter hebt met een eigenschap die vaak maar niet altijd wordt gebruikt.

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 User
{
  private $username = null;

  public function __construct($first_name = null, $last_name = null)
  {

    if (isset($first_name) && isset($last_name)) {
      $this->setUsername($first_name, $last_name);
    }
  }


  public function setUsername($first_name, $last_name)
  {

    $this->username = $first_name . ' ' . $last_name;
  }
}

?>
 
- Raoul -

- Raoul -

02/01/2013 14:10:34
Quote Anchor link
Dat eerste is idd rustiger, maar ik gaf een alternatief op 'lege arrays/variables meegeven in je constructor'
 
Ozzie PHP

Ozzie PHP

02/01/2013 14:14:57
Quote Anchor link
Ik begrijp het Raoul ;)

@Ward: dat snap ik inderdaad, maar het ging erom of je properties wel of niet "moet" declareren in de __construct functie.
 
Ward van der Put
Moderator

Ward van der Put

02/01/2013 14:35:46
Quote Anchor link
Niets moet, maar dat was al terecht gezegd :)

Feitelijk declareer je de class properties al direct bij het openen van de container class { … } met public, private of protected. En dat nog vóórdat je aan de slag gaat met de constructor.

Hoewel het technisch overbodig is, zou ik in dit geval dus ook een declaratie met = null gebruiken om expliciet in plaats van impliciet aan te geven dat een eigenschap in eerste instantie null is. Je hebt daarvoor namelijk een aparte setter in het leven geroepen. Bovendien is het niet vanzelfsprekend dat niet elke gebruiker een gebruikersnaam heeft.

Verder gebruik ik in lange listings vaak een lege constructor om aan te geven dat de constructor niet is vergeten maar verder geen rol speelt. Prototype wordt dan verkort:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
<?php
class User
{
  private $Username = null;

  public function __construct() {}
}

?>


Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje: wat zou $Username moeten zijn, waar en wanneer wordt $Username ingesteld, is $Username vereist of niet en waar is de constructor gebleven?
 
Ozzie PHP

Ozzie PHP

02/01/2013 14:45:34
Quote Anchor link
Grappig. Zo heeft iedereen blijkbaar z'n maniertjes. Ik zet zelf altijd de constructor bovenaan. Als ie niet bovenaan staat dan is ie er niet.

Je kunt dit wel declareren:

private $Username = null;

maar dat is precies hetzelfde als:

private $Username = null;

Dan zou ik dit nog logischer vinden:

private $Username = '';

omdat je dan kunt zien dat de variabele $username een string is.

Overigens grappig opmerking "Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje". Misschien zou je je classes een beetje korter moeten maken :D
 
Moose -

Moose -

02/01/2013 14:50:02
Quote Anchor link
Ozzie PHP op 02/01/2013 14:45:34:
Overigens grappig opmerking "Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje". Misschien zou je je classes een beetje korter moeten maken :D


Ik denk niet dat hij het heeft over tienduizenden regels code in 1 class. Heb je weleens aan een echt groot (denk aan > 1000 files) project gewerkt? Dan kan het heel goed voorkomen dat, zeker als je met meerdere mensen eraan werkt, de variablen op een rare plek aangepast worden
 
Ozzie PHP

Ozzie PHP

02/01/2013 14:53:55
Quote Anchor link
Zou kunnen, maar omdat het over class variabelen gaat ga ik er vanuit dat hij het over een class had. Ik heb zelf ook wel eens een lange class gemaakt. Stuk of 800 regels... achteraf wel een beetje overkill :)
 
Ward van der Put
Moderator

Ward van der Put

02/01/2013 14:56:03
Quote Anchor link
Nog logischer is dan een declaratie zoals:

private $stringUsername = (string) null;

Met (string) null geef je aan dat je een lege string declareert. Wie daar overheen leest, kan uit het prefix ‘string’ in $stringUsername en $User::stringUsername afleiden dat dit een string is.

Inderdaad... kwestie van smaak en stijl.
 
Moose -

Moose -

02/01/2013 14:59:03
Quote Anchor link
Dat lijkt me toch beter gedaan via documentatie. Die stijl die je hier beschrijft vind ik helemaal niks
 
Ozzie PHP

Ozzie PHP

02/01/2013 15:02:45
Quote Anchor link
"Inderdaad... kwestie van smaak en stijl."

Dat is het zeker Ward. Ik heb ook een tijd gehad dat ik alles aan het declareren was. Dan krijg je dit soort grappen:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
<?php
private $db_object = null;
private $first_name = '';
private $last_name = '';
private $age = 0;
private $hobbies = array();
private $is_webmaster = false;
private $has_rights = false;
?>


Dan leest dit toch een stuk prettiger en rustiger:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
<?php
private $db_object;
private $first_name;
private $last_name;
private $age;
private $hobbies;
private $is_webmaster;
private $has_rights;
?>


Uit veel variabelen namen kun je al afleiden wat het zou moeten zijn. En die enkele keer dat je het echt niet weet, zoek je het even op. Maar inderdaad, kwestie van smaak en stijl.
Gewijzigd op 02/01/2013 15:04:13 door Ozzie PHP
 
Ward van der Put
Moderator

Ward van der Put

02/01/2013 15:15:25
Quote Anchor link
Wat een paar extra spaties al niet doen:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
<?php
private $db_object    = null;
private $first_name   = '';
private $last_name    = '';
private $age          = 0;
private $hobbies      = array();
private $is_webmaster = false;
private $has_rights   = false;
?>


Elke ontwikkelaar heeft zo zijn gewoonten. En soms ook eigenaardigheden. In een class met veel eigenschappen gebruik ik bijvoorbeeld liefst een alfabetische volgorde, zelfs als dat betekent dat $Achternaam met een A ver voor $Voornaam richting de staart van het alfabet staat.
 

Pagina: 1 2 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.