[OOP] Arrays declareren in klassen

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Pagina: 1 2 volgende »

Ward van der Put
Moderator

Ward van der Put

17/01/2014 10:56:09
Quote Anchor link
Bij het doorspitten van verschillende PHP OOP-projecten viel me op dat er twee stijlen in omloop zijn voor het declareren van een array in een klasse.

Sommigen declareren direct een array in de class properties:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
<?php
class FooBar
{
    private $foo = array();
    private $bar = array();

    // <...>
}
?>

Anderen bewaren het voor de constructor of stellen het uit tot een setter wordt aangeroepen, schematisch:
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
<?php
class FooBar
{
    private $foo;
    private $bar;

    public function __construct()
    {

        $this->foo = array();
        // <...>
    }

    public function setBar($params)
    {

        $this->bar = array();
        // <...>
    }
}

?>

Wat zijn eigenlijk de voor- of nadelen van beide stijlen? En geldt hiervoor een best practice?
 
PHP hulp

PHP hulp

14/05/2021 03:09:09
 
Joakim Broden

Joakim Broden

17/01/2014 11:55:08
Quote Anchor link
Als het om een array gaat declareer ik het al in de class properties. Zodat het altijd een array is en de set nog niet gedaan hebt.

En ik set variabelen altijd via een setter dus niet via de construct, zo voorkom je dubbele code, stel ik wil een directory setten dan controlleer ik eerst of de directory bestaat en anders maak ik hem aan. Als ik dat al in de contructor zou doen en via een setter dan krijg je dubbele code. Daarom set ik altijd alles via een setter en die roep ik aan in de constructor (dit geld ook voor de getters).

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
22
23
24
25
26
27
28
29
30
31
<?php
    class FooBar {
        private $foo;
        private $bar;

        public function __construct($foo, $bar) {
            $this->setFoo($foo);
            $this->setBar($bar);
        }


        public function setFoo($foo) {
            $this->foo = $foo;
            
            return $this;
        }


        public function getFoo() {
            return $this->foo;
        }


        public function setBar($bar) {
            $this->bar = $bar;

            return $this;
        }


        public function getBar() {
            return $this->bar;
        }
    }

?>
Gewijzigd op 17/01/2014 11:55:35 door Joakim Broden
 
Ward van der Put
Moderator

Ward van der Put

17/01/2014 12:04:23
Quote Anchor link
Metal Hertog Jan op 17/01/2014 11:55:08:
Als het om een array gaat declareer ik het al in de class properties. Zodat het altijd een array is en de set nog niet gedaan hebt.

Maar dat garandeert niet dat de property een array blijft, want elders zou een ander datatype kunnen worden geset. Dan kun je toch beter setFoo(array $foo) gebruiken?
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
<?php
class FooBar
{
    private $foo;

    public function __construct(array $foo)
    {

        $this->setFoo($foo);
    }


    private function setFoo(array $foo)
    {

        $this->foo = $foo;
        return $this;
    }
}

?>
 
Joakim Broden

Joakim Broden

17/01/2014 13:39:07
Quote Anchor link
Ja klopt, was ook maar een voorbeeldje. Normaal gesproken doe ik in de setter $this->foo = (array) $foo. En soms gooi ik ook nog wel eens een exception als ik echt een een array of dergelijke verwacht.
 
Wouter J

Wouter J

17/01/2014 16:41:13
Quote Anchor link
In echte stricte OO talen is het niet mogelijk op defaults values op property niveau in te stellen. Je hebt hiervoor de constructor nodig, die ook eigenlijk als taak heeft dit te doen. In PHP kun je het dus ook op property niveau doen.

Welke beter is? Geen van beide (of allebei, net hoe positief je in het leven staan ;) ). Er is geen verschil tussen beide.

Op setter niveau declareren lijkt mij vrij nutteloos.
 
Erwin H

Erwin H

17/01/2014 22:35:08
Quote Anchor link
Ward van der Put op 17/01/2014 12:04:23:
Metal Hertog Jan op 17/01/2014 11:55:08:
Als het om een array gaat declareer ik het al in de class properties. Zodat het altijd een array is en de set nog niet gedaan hebt.

Maar dat garandeert niet dat de property een array blijft, want elders zou een ander datatype kunnen worden geset. Dan kun je toch beter setFoo(array $foo) gebruiken?

Theoretisch heb je gelijk, maar in mijn ogen heb je dan een serieuze fout in je class. Je class is als geheel verantwoordelijk voor zijn eigen properties en daarmee moet je binnen een class ervanuit kunnen gaan dat als een property een array moet zijn het dat dus altijd ook is. Binnen een class zou je wat mij betreft niet overal hoeven af te dwingen danwel te checken dat een private property is wat het moet zijn (waarmee ik dus ook maar weer eens impliciet aangeef waarom je bij mijn geen protected en public properties aantreft). Wat betreft declareren ga ik dan ook met Hertog Jan (maar ben ik het ook eens met Wouter dat het een niet per definitie beter is dan het ander).
Gewijzigd op 17/01/2014 22:35:42 door Erwin H
 
Local Dev

Local Dev

18/01/2014 00:08:32
Quote Anchor link
@Erwin H, wat is er fout aan "typehinting" van een setter?

Wanneer je wilt afdwingen dat een property wordt geset zoals de betreffende class verreisd, gebruik je typehinting (in dit geval is het array, ook zal dit vaak een verwijzing zijn naar een interface, en bij gebrek hiervan naar een class zelf), naar mijn mening is dit absoluut niet slecht maar juist goed, daar er wordt voorkomen dat de properties verkeerde waarden hebben.
 
Ozzie PHP

Ozzie PHP

18/01/2014 00:10:20
Quote Anchor link
Je kunt in een setter of constructor trouwens toch alleen typehinten op een array of object (en niet op een string of int)? Correct?
 
Local Dev

Local Dev

18/01/2014 00:14:32
Quote Anchor link
correct
 
Ozzie PHP

Ozzie PHP

18/01/2014 00:17:56
Quote Anchor link
allright... just checking... wel vreemd eigenlijk dat je niet kunt typehinten op een string of int...
 
Erwin H

Erwin H

18/01/2014 09:15:27
Quote Anchor link
Local Dev op 18/01/2014 00:08:32:
@Erwin H, wat is er fout aan "typehinting" van een setter?

Niets mis met het typehinten van een setter. Zeker niet als de setter public of protected is. Waar het mij om gaat is dat binnen de class je verder niet meer zou moeten hoeven checken dat het een array is. De setter (of constructor, of definitie) moet bepalen dat het een array is en vervolgens mag je overal in de class ervanuit kunnen gaan dat het ook daadwerkelijk een array is. Check alleen alles wat van buiten komt, niet wat van binnen komt.
 
Wouter J

Wouter J

18/01/2014 10:41:30
Quote Anchor link
Ozzie, dat heb ik je al eens eerder uitlegt, maar maakt niet uit :) PHP kan zonder problemen "type jugglen" tussen ints en strings, dus als je een int geeft waar je een string verwacht maakt PHP gewoon leuk een string van die int. Als je een string hebt waar je een int verwacht gaat het iets krommer, maar het eind resultaat is hetzelfde: Je krijgt alsnog een int. ("abc123" wordt 123)
Een array kan PHP niet op die manier "type jugglen" naar een string of een int. Bij het omzetten naar een string krijg je "Array", totaal niet wat je verwacht. Bij het omzetten naar een int zal je 0 of 1 krijgen, en als je dat doet doormiddel van rekenoperator krijg je "Fatal error: Unsupported operand types".
Het typehinten van objecten is gewoon volledig omdat dat 1 van de keyprincipes is van OOP.
 
Ozzie PHP

Ozzie PHP

18/01/2014 17:00:16
Quote Anchor link
Ah, dankjewel voor de opfrisser Wouter!

Maar ergens ook wel een beetje inconsequent...

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
<?php

public function setProductProperties($code, array $properties) {

}


?>

Hier weet je dus dat $properties een array moet zijn, maar wat is $code? Een int of een string?

Ik denk trouwens dat het in de praktijk voldoende is om alleen objecten te typehinten. Als het goed is kun je aan de naam van de variabele zien of iets een array is, omdat de naam dan meervoud is: properties (array) versus property (string).
Gewijzigd op 18/01/2014 17:00:48 door Ozzie PHP
 
Wouter J

Wouter J

18/01/2014 17:44:42
Quote Anchor link
Ozzie, type hinting is alleen handig voor de code. Het maakt niet uit of het een int of een string is, aangezien het beide in beide gevallen bruikbaar is.

Dat een argument meervoudig of enkelvoudig heeft ook totaal geen nut, dat weet PHP niet. Het type hinten op classen en arrays heeft de code als doel, niet de documentatie.
 
Ozzie PHP

Ozzie PHP

18/01/2014 17:57:32
Quote Anchor link
Laatste vraag, anders dwalen we te veel af...

Wat is dan het nut van het typehinten van een parameter? Dat is toch om te voorkomen dat je een verkeerd type opgeeft? Want als je dit hebt:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
<?php
public function foo(array $bar) {

}

?>

En je geeft een int als argument in plaats van een array, dan krijg je een foutmelding. In die zin is het toch een vorm van documentatie, zodat je zelf weet wat $bar zou moeten zijn?
 
Ger van Steenderen
Tutorial mod

Ger van Steenderen

18/01/2014 19:01:20
Quote Anchor link
(php.net)>>Failing to satisfy the type hint results in a catchable fatal error.
Met andere woorden een exception.
 
Ozzie PHP

Ozzie PHP

19/01/2014 01:11:20
Quote Anchor link
Een error is toch geen exception? Maar wat ik eigenlijk bedoel is... het is toch een soort documentatie? Het doet verder toch niets? Stel ik geen bijv. een int op ipv een array, dan maakt ie daar niet ineens een array van. Dus wat is dan het nut? Volgens mij alleen dat je kunt zien wat er voor type verwacht wordt...

Offtopic:

Ward, geef je aub even een gil als we te veel afdwalen, of als je nog vragen hebt?
 
Local Dev

Local Dev

19/01/2014 01:27:24
Quote Anchor link
Waarom kan een error geen exception zijn??

En nee, typehinting is geen documentatie maar het afdwingen van de juiste parameters.
Gewijzigd op 19/01/2014 01:29:58 door Local Dev
 
Ozzie PHP

Ozzie PHP

19/01/2014 01:32:16
Quote Anchor link
Ik bedoel... in PHP is een error toch iets anders dan een Exception?

Oké... maar als ik dus het verkeerde type opgeef, dan volgt er een error. Het is niet zo dat dit type dan wordt omgezet naar het juiste type. Dat bedoel ik eigenlijk.
 
Wouter J

Wouter J

19/01/2014 09:03:01
Quote Anchor link
>> Ik bedoel... in PHP is een error toch iets anders dan een Exception?

Sommige errors wel. Dit is een catchable fatal error, iets wat je kunt opvangen in een catch statement dus.
 
Ozzie PHP

Ozzie PHP

19/01/2014 11:20:34
Quote Anchor link
>> Sommige errors wel. Dit is een catchable fatal error, iets wat je kunt opvangen in een catch statement dus.

Pfff, ik blijf iedere dag nieuwe dingen leren. En catch ik die gewoon als een algemene exception? Dus zo:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
<?php
try {

}
catch(Exception $e) {

}

?>

Of werkt dat op een andere manier?
 

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.