[PHP] OOP functie

[g4wx3]

Ik zoek een bepaalde OOP functie, maar kan het niet vinden.

Ik wil een puch-pull systeem opzetten, en wil moet dus de naam van de objecten dorgeven (niet de objecten zelf). zoiets als: get_name($this).
Ik zou de naam kunnen doorgeven met argumenten, maar dat is compleet onzinnig, want het is helemaal niet relevant in het "verhaal".


Ik probeer te illustreren met een fictief voorbeeld.

PHP:

<?php
$wereld = new werelden;
$koe = new dier("melk");

class dier
{
function __construct("product")
{
# Het gaat dus om deze regel:
$wereld->nieuw(get_name($this));
}
function get_actie()
{
return "melk";
}
}

class werelden
{
function nieuw($objectnaam)
{
$array[] = $objectnaam;
}
function maakwereld()
{
$wereldactie = '';
foreach( $array as $objectnaam)
{
$wereldactie .= $objectnaam->get_actie();
}
return $wereldactie;
}
}

*heb een beetje php gekribbeld hier, hoop dat het duidelijk is.

[CH4OS]

Het zou allicht schelen als je de opmaak van je code wat beter leesbaarder maakte...
Misschien zie je dan zelf ook of er iets niet goed is...

PHP:

function foo()
{
    return $foo->bar;
}

Zo bedoel ik... Dan zie je tenminste wat de functie moet doen...

[NetForce1]

deze al gezien: http://nl3.php.net/__autoload ?

[Confusion]

g4wx3 schreef op maandag 30 juni 2008 @ 22:16:
Ik wil een puch-pull systeem opzetten

Een wat?

en wil moet dus de naam van de objecten dorgeven (niet de objecten zelf). zoiets als: get_name($this).

Wat is 'de' naam van een object? Bedoel je daarmee een eigenschap die jij aan objecten toekent of een eigenschap die ze volgens jou al zouden moeten hebben?

In beide gevallen geldt: als je de naam aan de hand van het object kan bepalen, dan kan je natuurlijk ook het object 'doorgeven' en de naam bepalen op de plek waar de objectreferentie beschikbaar is gekomen.

hoop dat het duidelijk is.

Helaas, nee. Ik heb geen flauw idee wat je wilt.

[Cyphax]

Confusion schreef op maandag 30 juni 2008 @ 22:34:
[...]

Een wat?


[...]

Wat is 'de' naam van een object? Bedoel je daarmee een eigenschap die jij aan objecten toekent of een eigenschap die ze volgens jou al zouden moeten hebben?

In beide gevallen geldt: als je de naam aan de hand van het object kan bepalen, dan kan je natuurlijk ook het object 'doorgeven' en de naam bepalen op de plek waar de objectreferentie beschikbaar is gekomen.


[...]

Helaas, nee. Ik heb geen flauw idee wat je wilt.

Hij wil eigenlijk de naam van de variabele (van de instantie van het object) doorgeven. Ik heb dat ook een keer geprobeerd, maar dat is dus nog niet zo makkelijk, de functie die g4wx3 zoekt is er volgens mij dus niet zo even.

[ValHallASW]

met indenting:

g4wx3 schreef op maandag 30 juni 2008 @ 22:16:

PHP:

<?php
$wereld = new werelden;
$koe = new dier("melk");

class dier
{
  function __construct("product")
  {
    # Het gaat dus om deze regel:
    $wereld->nieuw(get_name($this));
  }
  function get_actie()
  {
    return "melk";
  }
}

class werelden
{
  function nieuw($objectnaam)
  {
    $array[] = $objectnaam;
  }
  function maakwereld()
  {
    $wereldactie = '';
    foreach( $array as $objectnaam)
    {
      $wereldactie .= $objectnaam->get_actie();
    }
    return $wereldactie;
  }
}

1) wat doe je met globals als je OOP bezig bent
2) je doet absoluut niets met de naam van het object
3) de naam van het object heeft geen 1-op-1-relatie met het object:

PHP:

$a = new Ding();
$b = $a;

wat is dan de naam van $a?
4) mocht je bedoelen dat je het type wilt weten -> http://nl.php.net/manual/en/function.get-class.php

maar ik heb vooral het vermoeden dat je zelf geen idee hebt waar je mee bezig bent

[NetForce1]

Cyphax schreef op maandag 30 juni 2008 @ 22:40:
[...]

Hij wil eigenlijk de naam van de variabele (van de instantie van het object) doorgeven. Ik heb dat ook een keer geprobeerd, maar dat is dus nog niet zo makkelijk, de functie die g4wx3 zoekt is er volgens mij dus niet zo even.

wtf, waar zou je dat nu toch weer voor willen

[Jaap-Jan]

Kun je $this niet by reference doorgeven? Dus deze regel:

PHP:

function nieuw($objectnaam)

veranderen naar:

PHP:

function nieuw(&$objectnaam)

Je zou een adres toch wel kunnen zien als een 'naam'. Het is in ieder geval een gegeven uniek voor dat object.

@NetForce1, volgens mij om een object op te kunnen slaan in een array, voor zover ik uit het codevoorbeeld kan opmaken.

Brak codevoorbeeld trouwens:

PHP:

function __construct("product")

slaat nergens op.

[ Voor 29% gewijzigd door Jaap-Jan op 30-06-2008 22:54 ]

[NetForce1]

Jaap-Jan schreef op maandag 30 juni 2008 @ 22:49:
Kun je $this niet by reference doorgeven? Dus deze regel:

PHP:

function nieuw($objectnaam)

veranderen naar:

PHP:

function nieuw(&$objectnaam)

Je zou een adres toch wel kunnen zien als een 'naam'. Het is in ieder geval een gegeven uniek voor dat object.

@NetForce1, volgens mij om een object op te kunnen slaan in een array, voor zover ik uit het codevoorbeeld kan opmaken.

Gaar, in dit geval zou dat toevallig goed gaan omdat de scope goed is, maar anders gaat dat natuurlijk nooit werken. Beter lijkt met om gewoon het object zelf door te geven met $this (afaik zijn objecten altijd by-ref in php5). Maar dan nog vraag ik me af of dit de juiste oplossing is voor het probleem van ts, het is namelijk niet bekend wat hij hiermee probeerd op te lossen.

[Jaap-Jan]

NetForce1 schreef op maandag 30 juni 2008 @ 22:57:
[...]

Gaar, in dit geval zou dat toevallig goed gaan omdat de scope goed is, maar anders gaat dat natuurlijk nooit werken. Beter lijkt met om gewoon het object zelf door te geven met $this (afaik zijn objecten altijd by-ref in php5). Maar dan nog vraag ik me af of dit de juiste oplossing is voor het probleem van ts, het is namelijk niet bekend wat hij hiermee probeerd op te lossen.

Klopt, alleen in PHP 3 en 4 by value, dus deze constructie is ook niet nodig. Nu ik het ook zie, wordt mij uit het codevoorbeeld ook helemaal niet duidelijk wat het probleem is.

Een werkend voorbeeld (zonder die get_name() of wat dat ook moge doen):

PHP:

$wereld = new werelden();
$koe = new dier($wereld, "melk");
print_r($wereld->array);
print $wereld->maakwereld();

class dier
{
        function __construct($wereld, $product)
        {
                # Het gaat dus om deze regel:
                $wereld->nieuw($this);
        }

        function get_actie()
        {
                return "melk";
        }
}

class werelden
{
        public $array = array();

        function nieuw($objectnaam)
        {
                $this->array[] = $objectnaam;
        }

        function maakwereld()
        {
                $wereldactie = '';
                foreach( $this->array as $objectnaam)
                {
                        $wereldactie .= $objectnaam->get_actie();
                }
                return $wereldactie;
        }
}

Wat is hier niet goed genoeg aan, TS? Zeg nou niet public membervariabelen, want dat weet ik zelf ook wel.

[Cyphax]

NetForce1 schreef op maandag 30 juni 2008 @ 22:42:
[...]

wtf, waar zou je dat nu toch weer voor willen

In mijn geval alleen om een overzicht bij de houden van de objecten op een pagina voor wat debugging.

[NetForce1]

Cyphax schreef op maandag 30 juni 2008 @ 23:49:
[...]

In mijn geval alleen om een overzicht bij de houden van de objecten op een pagina voor wat debugging.

Hoe kom je dan aan een lijst met al die objecten? Als je die zelf in code samenstelt kun je natuurlijk net zogoed zelf de naam daar ook opgeven.

[Cousin Boneless]

Volgens mij is TS op zoek naar een soort Factory Method design pattern. En wil hij de volgende zin vertalen naar programmacode:

Applicatie: wereld, creeer voor mij een nieuwe koe.

PHP:

$koe = $wereld->createAnimal(koe_type);

waarbij koe_type een class-reference is en $koe de instantiatie die aan de wereld is toegevoegd.

Er zijn situaties denkbaar dat 'wereld' de koe heeft gemaakt met eigenschappen die voor de wereld private zijn. Helaas zijn mij geen class references bekend binnen PHP, dus open de trukendoos:

PHP:

class World
{
    public animals[];
    private privateWorldData;
    
    function World()
    {
        $this->privateWorldData = 'something only God will know about';
    }
    
    function &createAnimal($createAnimalProc)
    {
        $newAnimal = call_user_func($createAnimalProc, $this->privateWorldData);
        $this->animals[] = &$newAnimal;
        return $newAnimal;
    }

    function print()
    {
        foreach($this->animals as $animal)
          echo $animal->getProduct();
    }
}

// each descendant has to implement the function getProduct()
// cannot force this with an abstract function in PHP
class AbstractAnimal
{
    private privateWorldData;
    
    function AbstractAnimal($privateWorldData)
    {
        $this->privateWorldData = $privateWorldData;
    }
}

class Cow extends AbstractAnimal
{
    function Cow($privateWorldData)
    {
        parent::AbstractAnimal($privateWorldData);
    }
    
    // my virtual function
    function getProduct()
    {
        return 'milk';  
    }
}

class Chicken extends AbstractAnimal
{
    function Chicken($privateWorldData)
    {
        parent::AbstractAnimal($privateWorldData);
    }
    
    // my virtual function
    function getProduct()
    {
        return 'eggs';
    }
}

// application
function &createACow($privateWorldData)
{
    $newCow = new Cow($privateWorldData);
    return $newCow;
}

function &createAChicken($privateWorldData)
{
    $newChicken = new Chicken($privateWorldData);
    return $newChicken;
}

$world = new World();

$cow = $world->createAnimal('createACow');
$chicken = $world->createAnimal('createAChicken');

$world->print();

[ Voor 27% gewijzigd door Cousin Boneless op 01-07-2008 00:55 ]

[Confusion]

Cousin Boneless schreef op dinsdag 01 juli 2008 @ 00:32:
Volgens mij is TS op zoek naar een soort Factory Method design pattern.
[..]
Helaas zijn mij geen class references bekend binnen PHP,

Als ik in Java het Factory Method patroon implementeer, dan ga ik dus niet vervolgens roepen factoryInstance.getObject(Impl1.class). That deafeats the purpose of the pattern. Om een factory method te implementeren heb je geen class reference of, God forbid, instantie van het te creeeren object nodig.

[Cousin Boneless]

@Confusion: Zo beter? Of doelde je hier niet op? Werkt wel die call-back weg, maar geeft wel extra overhead:

PHP:

<?php
// each descendant has an abstract public function createAnimal($privateWorldData)
class AbstractAnimalFactory
{..}

class CowFactory extends AbstractAnimalFactory
{
    ...
    
    function &createAnimal($privateWorldData)
    {
        return new Cow($privateWorldData);
    }
}

class ChickenFactory extends AbstractAnimalFactory
{
    ...
    
    function &createAnimal($privateWorldData)
    {
        return new Chicken($privateWorldData);
    }
}

$world = new World();
$world->createAnimal(new CowFactory());
$world->createAnimal(new ChickenFactory());
...
?>

[ Voor 8% gewijzigd door Cousin Boneless op 01-07-2008 11:51 ]

[Cyphax]

NetForce1 schreef op maandag 30 juni 2008 @ 23:54:
[...]

Hoe kom je dan aan een lijst met al die objecten?

Door de constructor van het object zich te laten registreren in een debuggingobject waar je referenties opslaat, dan zou het wel leuk zijn als je de naam van de variabele er ook bij hebt.

[NetForce1]

Cyphax schreef op dinsdag 01 juli 2008 @ 11:36:
[...]

Door de constructor van het object zich te laten registreren in een debuggingobject waar je referenties opslaat, dan zou het wel leuk zijn als je de naam van de variabele er ook bij hebt.

Ok, daar heb je wel een geinige toepassing idd. Kun je dat niet bereiken door een native uitbreiding te schrijven op php? (heb daar nooit naar gekeken, geen flauw idee wat de mogelijkheden daarvan zijn).

[compufreak88]

Cyphax schreef op dinsdag 01 juli 2008 @ 11:36:
[...]

Door de constructor van het object zich te laten registreren in een debuggingobject waar je referenties opslaat, dan zou het wel leuk zijn als je de naam van de variabele er ook bij hebt.

Zoals al eerder gezegd: De naam van de variabele staat niet vast. Meerdere variabelen kunnen naar 1 object verwijzen.

Dit is imo dus ook niet mogelijk.

[g4wx3]

Allereerst iedereen bedankt voor de moeite, heb weer veel geleerd.
Nu heb ik code die werkt zoals gewenst.
Probleem zat niet bij het doorgeven van het object, maar domweg bij de scope van de gebruikte variabele waardoor ik die niet kon gebruiken in verschillende objecten.

Om de variabele dus in verschillende objecten te gebruiken moet ik die als een global toewijzen,of via de superglobal aanroepen. Wat ik doe.

Hier de echt gebruikte code, maar men classen zijn nog lang niet af (eerder net begonnen)

PHP:

class page
{
    var $_objects;
    var $_title;
    var $_keywords;
    function page()
    {
        $this->_object = array();
        $this->_title = '';
        $this->_keywords = '';
    }
    function new_object($object)
    {
        $this->_objects[] = $object;
    }
    function get_html()
    {
        $html = '';
        foreach($this->_objects as $object)
        {
            $html .= $object->get_html();
        }
        echo $html;
    }
    function get_css()
    {
        $css = '';
        foreach($this->_objects as $object)
        {
            $css .= $object->get_css();
        }
        echo $css;
    }
}

$page = new page;

class FORM
{
    var ..;
    
    function FORM($name='form')
    {
        #probleem - global
        $GLOBALS['page']->new_object($this);    
        $this->_labellength = 0;
        $this->set_name($name);
    }
.....
}

[NetForce1]

Waarom wil je form zichzelf laten registreren bij de global page. Het is imho beter om dat te laten doen door de code die een form maakt, dus:

PHP:

$page = new page();
$mySuperForm = new Form();
$page->new_object($mySuperForm);

Of anders page meegeven aan de constructor van form als je page echt nodig hebt in form.

[SchizoDuckie]

Bedoel je nou niet gewoon

PHP:

echo __CLASS__ // vanuit een class

of bedoel je misschien [google=late static binding php]

[LuCarD]

Probeer je zoiets te doen?

PHP:

<?php

class page {
    static $instance = null;
    
    private $waarde = 1;
    
    function getInstance()  {
        if (self::$instance == null) 
            self::$instance = new page();
            
        return self::$instance;
    }

    function setWaarde($int = 0){
        $this->waarde = $int;
    }
    
    function getWaarde() {
        return $this->waarde;
    }
}

class form {
    
    private $pageInstance;
    function __construct() {
        $p = page::getInstance();
        $this->pageInstance=$p;
    }
    
    function getWaardePage(){
        return $this->pageInstance->getWaarde();
    }

}

$page = page::getInstance();

echo "<br>Waarde van page: " . $page->getWaarde();

$f = new form();

echo "<br>Waarde van page binnen \$f: " . $f->getWaardePage();

$f2 = new form();

echo "<br>Waarde van page binnen \$f2: " . $f2->getWaardePage();

$page->setWaarde(100);

echo "<br>Waarde van page binnen \$f: " . $f->getWaardePage();
echo "<br>Waarde van page binnen \$f2: " . $f2->getWaardePage();
echo "<hr>";
show_source(__FILE__);
?>