[php] OO return meerdere vars

[Freemann]

Zit ff te stoeien met een "probleem" dat ik uit een class->function meerdere vars wil return-en.


ik heb het volgende(alles is uitgekleed omdat het anders te groot wordt):

PHP:

class stats extends kosten {
    var $color;
    var $total;

    function home(){
        $this->$color = "#ffffff";
        $this->$total = 10;
    }

}

nu heb ik het volgende gedaan om de var's in 1 keer te return-en:

PHP:

    $objectVars = get_object_vars($this);
    $serializeVars = array();

    foreach ($objectVars as $key => $val) {
        $serializeVars[] = $sKey;
    }
        
    return $this->$serializeVars;

en ik krijg dan:

PHP:

class stats extends kosten {
    var $color;
    var $total;

    function home(){
        $this->$color = "#ffffff";
        $this->$total = 10;

        //vars geschikt maken om in 1 keer te return-en
        $objectVars = get_object_vars($this);
        $serializeVars = array();

        foreach ($objectVars as $key => $val) {
            $serializeVars[] = $sKey;
        }
        
        return $serializeVars;
    }

}

Nu doe ik het volgende om de functie aan te roepen:

PHP:

        $stats = new stats();
        $inhoud = $stats->home->$serializeVars;

        // "debuggen"
        echo "<pre>";
        var_dump($inhoud);
        echo "<pre>";

Helaas krijg ik geen output...heb lopen klooien/doen maar kom er niet uit...
Het zal vast weer heel makkelijk zijn en iets over het hoofd zien maar ik zie het niet...

[4Real]

PHP:

<?php

function x()
{
    return array('var1', 'var2');
}

list($var1, $var2) = x();

?>

zoiets

[Verwijderd]

Je kunt toch gewoon de var's opvragen?
$color = $stats->home->color
?

Dat is namelijk OO programmeren

[mithras]

Wat je doet in je derde snippet op regel 2 klopt sowieso niet. Je wil waarschijnlijk iets als:

PHP:

$serializeVars = $stats->home();

Maar dat is imho niet de juiste oplossing. Je kan beter een dergelijke klasse maken:

PHP:

class Stats extends Kosten
{
  private $_color;
  private $_total;

  public function __construct()
  {
    $this->_color = '#ffffff';
    $this->_total = 10;
  }

  public function getColor ()
  {
    return $this->_color;
  }

  public function getTotal ()
  {
    return $this->_total;
  }
}

$stats = new Stats;
$inhoud = array (
  'total'  => $stats->getTotal(),
  'color' => $stats->getColor()
  );

[Herko_ter_Horst]

N.m. Wat ik wou zeggen is al gezegd en uitgelegd met voorbeeld.

[ Voor 81% gewijzigd door Herko_ter_Horst op 23-07-2009 11:53 ]

[DexterDee]

Ik vind het gebruik van get_object_vars niet de beste methode om je class variabelen te ontsluiten. Een class heeft een bepaalde semantische betekenis die je om zeep helpt door letterlijk alle variabelen te willen dumpen in een return.

Beter is als je bepaalde properties public maakt, zodat je ze kan aanroepen vanuit het aanroepende script. Als je toch meerdere waarden wil retourneren, construeer dan een associative array van bepaalde relevante waarden die je ter plekke in de method bijelkaar raapt. Dan geef je ook enige semantische betekenis aan die return value.

Het retourneren van een associative array van waarden wordt trouwens in de wereld van OO vaak niet als de beste oplossing gezien. Een betere oplossing is vaak een BO (business Object) maken en die retourneren. Dit BO is een class die alle waarden bevat die relevant zijn voor de relevante business logic.

[Shagura]

nvm moet vaker refreshen

[ Voor 178% gewijzigd door Shagura op 23-07-2009 11:53 ]

[Freemann]

Tja iedereen moet het een keer leren....

Ik ga is kijken wat ik ermee kan

[.oisyn]

De fout is dat je een $ gebruikt na de ->. Dat moet niet (sterker nog, dat gaat fout, omdat in het geval van $this->$color dan eerst $color wordt opgezocht, die niet bestaat, en dat wordt gebruikt om de waarde uit $this te halen, die dus ook niet bestaat)

[Peter]

Ehm, hier gebruik je arrays voor.

PHP:

class foo
{
    private $m_bBoolean;
    private $m_sString;
    
    public function __construct () {}
    public function getData ()
    {
        return array
        (
            $this -> m_bBoolean,
            $this -> m_sString
        );
    }
}

$bar = new foo ();
$items = $bar -> getData ();

echo $items [1]; // foo :: $m_sString

Nog beter zouden losse getters zijn met meerdere calls, al kost dat weer (aldanniet minimaal) performance. Kijk sowieso even naar propere OO in PHP.

[--MeAngry--]

Hehe, je zegt OO te programmeren, maar vervolgens ga je om het OO heenwerken.

Daarnaast, $this->$variabele doet niet wat jij wilt denk ik. Ik zou eens even goed de handleiding van PHP nasnuffelen of je wel een tweede $ wilt gebruiken.

edit:

Dikke spuit 11

[ Voor 6% gewijzigd door --MeAngry-- op 23-07-2009 11:54 ]

[MueR]

Probeer ook absoluut geen PHP 4 classes te maken. Gebruik PHP5, zoals mithras in "[php] OO return meerdere vars" laat zien.

[Freemann]

oke me ego is in 12 min. (begin post tot laatste reactie) ff ingetrapt

iedereen leert met vallen en opstaan en ik geloof ook dat dit niet de meest goede "OO" code is.

[H004]

Freemann schreef op donderdag 23 juli 2009 @ 11:44:

PHP:

    foreach ($objectVars as $key => $val) {
        $serializeVars[] = $sKey;
    }

Daarnaast zal $serializeVars zo natuurlijk ook altijd leeg blijven

[Grijze Vos]

In dit geval is een oplossing zoals Mithras aangeeft het beste. Gewoon de instantie van de class zelf passen naar waar je de data nodig hebt, en op die plek in je code de getters en setters aanspreken.

Mocht je in de toekomst nou toevallig een keer een functie nodig hebben die bijv. twee waardes moet returnen, gebruik dan gewoon reference parameters. (Of `out` parameters, als je taal dat ondersteund.)

[DexterDee]

Grijze Vos schreef op donderdag 23 juli 2009 @ 12:33:
In dit geval is een oplossing zoals Mithras aangeeft het beste. Gewoon de instantie van de class zelf passen naar waar je de data nodig hebt, en op die plek in je code de getters en setters aanspreken.

Mocht je in de toekomst nou toevallig een keer een functie nodig hebben die bijv. twee waardes moet returnen, gebruik dan gewoon reference parameters. (Of `out` parameters, als je taal dat ondersteund.)

Alsjeblieft geen referenced parameters. Waarom zoveel native functies dat in PHP vereisen is mij een compleet raadsel. Waarschijnlijk omdat dat hip was in 1998 en ze graag backwards compatible willen blijven. Om meerdere redenen is dat behoorlijk not-done. Het correcte design pattern voor de meeste professionele programmeurs om meerdere variabelen te retourneren via een method is het gebruiken van een business object. Maar vaak kan er wel omheen gewerkt worden door de logica iets anders te implementeren.

[Voutloos]

En zet display_errors en error_reporting op een beetje leuke instelling, want je negeert nu moeilijk veel errors.

[RobIII]

DexterDee schreef op donderdag 23 juli 2009 @ 12:56:
Alsjeblieft geen referenced parameters... <snip> ...Het correcte design pattern voor de meeste professionele programmeurs om meerdere variabelen te retourneren via een method is het gebruiken van een business object.

Nah; ze zijn niet per definitie "evil", ze kennen hun plaats wel. Maar in het geval van TS is dat inderdaad niet aan de orde.

[ Voor 5% gewijzigd door RobIII op 23-07-2009 13:11 ]

[.oisyn]

DexterDee schreef op donderdag 23 juli 2009 @ 12:56:
Om meerdere redenen is dat behoorlijk not-done

Als je dan per se wilt opvoeden, vertel er dan ook meteen bij waarom

Het correcte design pattern voor de meeste professionele programmeurs om meerdere variabelen te retourneren via een method is het gebruiken van een business object.

Een beetje kort door de bocht. Het is duidelijk een onvolkomenheid van de taal waar je omheen moet werken - dat ie maar 1 returnvalue support bedoel ik dus. Maar je kunt net zo goed een array gebruiken als (named) tuple, icm de list() syntax, wat erg vergelijkbaar is met talen die wél meerdere returnvalues ondersteunen. Dat kun je wel afdoen als niet OO, maar als je krampachtig aan OO blijft vasthouden ben je vergeten waarom je eigenlijk überhaupt OO aan het gebruiken was. Het is een middel, geen doel op zich. Het doel is cleane en onderhoudbare code. Een array() icm list() doet daar imho niets aan af.

[ Voor 15% gewijzigd door .oisyn op 23-07-2009 13:34 ]

[DexterDee]

.oisyn schreef op donderdag 23 juli 2009 @ 13:21:
[...]
Een beetje kort door de bocht. Het is duidelijk een onvolkomenheid van de taal waar je omheen moet werken - dat ie maar 1 returnvalue support bedoel ik dus. Maar je kunt net zo goed een array gebruiken als (named) tuple, icm de list() syntax, wat erg vergelijkbaar is met talen die wél meerdere returnvalues ondersteunen. Dat kun je wel afdoen als niet OO, maar als je krampachtig aan OO blijft vasthouden ben je vergeten waarom je eigenlijk überhaupt OO aan het gebruiken was. Het is een middel, geen doel op zich. Het doel is cleane en onderhoudbare code. Een array() icm list() doet daar imho niets aan af.

Klopt, het is ook kort door de bocht. Ik ben het met je eens dat maintainable, extensible code het uiteindelijke doel is. Het hele idee van OOP is dat je bepaalde semantiek in een objectgeorienteerde manier vastlegt. Het returnen van een (associative) array bevat per definitie nauwelijks semantiek. Door een object hiervoor te gebruiken kun je gebruik maken van een stukje validatie, wat erg goed van pas gaat komen als je met meerdere ontwikkelaars werkt en één ontwikkelaar besluit de uitvoer te veranderen. Natuurlijk is dat niet in alle gevallen noodzakelijk en soms wellicht zelfs niet wenselijk. Maar de reden waarom ik deze oplossing naar voren heb geschoven is omdat ik vaker tegen kom dat het niet gebruikt wordt op plaatsen waar het juist wel veel toegevoegde waarde heeft. Het teruggeven van een array is niet iets waar ik structureel op tegen ben, mocht ik die indruk in mijn vorige post hebben gewekt. Ik heb het in ieder geval wel als optie genoemd.