[php]Return class wat daar pas is aangemaakt

[chielsen]

Ik wil in een functie een class terug die op die plek ook wordt gemaakt.

DUs bijv

PHP:

<?
function test()
{
return class
{
function test2()
{
echo 'Hallo';
}
}
}

//En dat je dan dit kan doen
$obj = test();
$obj->test2(); //Zou dan Hallo moeten echoen
?>

Ik wil het graag zo omdat dat in mijn geval duidelijk is (om bovenstaande manier gebruik ik het niet maar het gaat om de werking.
Kan dat?

Ik kan niet echt zoeken want ik weet niet hoe je dit noemt. Ik heb op subclass ed gezocht maar daar krijgt je dit natuurlijk niet bij..

[ Voor 8% gewijzigd door chielsen op 13-12-2005 17:58 ]

[.oisyn]

Waarom? Waarom definieer je niet gewoon een bepaalde klasse die je instantieert en teruggeeft?

PHP:

class Test2
{
    function test2() { echo 'Hallo'; }
};

function test()
{
    return new Test2();
}

$obj = test();
$obj->test2();

[T-MOB]

Mocht je het echt letterlijk willen zoals in je topicstart dan kun je ook de klasse definieren binnen de functie. Je moet dan alleen wel checken of de klasse niet al eens is gedefinieerd. Kortom het wordt er allemaal niet mooier op. Ik zou dus voor .oisyn's methode gaan, tenzij je een hele goede reden hebt om dat niet te doen...

PHP:

function test() {

    //define class only once
    if (!class_exists('foo')) {

        class foo {
            function test() {
                echo 'succes';
            }
        }
    }

    return new foo();
}

$obj = test();
$obj->test();

[Michali]

Je wilt dus een functie laten bepalen van wat voor class je een instantie krijgt? Zo'n functie noem je dan een Factory (een design pattern), waarmee je inderdaad de keuze van welke class een instantie wordt aangemaakt en/of hoe deze wordt geconstrueerd los koppelt van de client code. Verder denk ik dat je het verschil niet helemaal begrijp tussen een class definitie en een instantie ervan. Een hele definitie kun je niet terug geven. Waar je de definitie neerzet is in princiepe ook niet zo van belang, als deze maar wel bekend is als je er een instantie van wilt gaan maken. En een instantie is dan een object, die zich gedraagt zoals gedefinieerd in de class definitie. Bij het instantieeren moet je het type opgeven, maar dat is dan weer los te koppelen mbv. een Factory, die hem voor je aanmaakt. Ik hoop dat ik niet te ver ga met mijn uitleg, anders moet je dat maar even aangeven

[chielsen]

Ja ik wil het wel graag zo want dat maakt het voor mij een stuk makkelijker.
Ik heb een switch die verschillde objecten teruggeeft.
Maar de code voor die classes gebruik ik voor de rest nergens. Ik hoef hem dus niet te kunnen instancieren. Als ik losse classes maak en die weer buiten de code zet is dat een stuk onoerzichtelijker Ik wil net als in javascript een variable class aan kunnen maken.

PHP:

<?
function test($x)
{
    switch ($x)
    {
        case 1 :
        {
            return class
            {
                function open()
                {
                    echo file_get_contents(_BESTAND_);
                }
            }
        }
        
        case 2 :
        {
            return class
            {
                function open()
                {
                    print_r(file(_BESTAND_));
                }
            }
        }
    }
}

$een = test(1);
$twee = test(2);

$een->open();
$twee->open();
?>

[Michali]

Wellicht is dit dan handig:

PHP:

<?
function test($x)
{
    if ( !class_exists("Object1") )
    {
        class Object1
        {
            function open()
            {
                echo file_get_contents(_BESTAND_);
            }
        }
    }
    
    if ( !class_exists("Object2") )
    {
        class Object2
        {
            function open()
            {
                print_r(file(_BESTAND_));
            }
        }
    }
    
    $class = "Object" . $x;
    return new $class;
}

$een = test(1);
$twee = test(2);

$een->open();
$twee->open();
?>

Ik vind het verder wel een vreemde manier van werken. Beter is om je classes gewoon een duidelijke naam te geven. Wat je hier probeert heet trouwens Strategy of Policy (in design pattern taal). Beter is om je classes gewoon een duidelijk naam te geven, over wat ze proberen te bereiken.

[ Voor 44% gewijzigd door Michali op 13-12-2005 19:01 ]

[chielsen]

Tja tis een beetje een gevoelskwestie. Ik vind het niet echt belangrijk genoeg om voor al die opties apart een class aan te maken (zal ik dan wel verkeerd hebben), maar ik wil wel graag dat wat ik return een class is die voor welke case ook hetzelfde doet (uitwendig, inwendig dus anders).
Misschien dus toch maar losse classes maken dan.

Ik vind trouwens niks over "Strategy of Policy"

[ Voor 7% gewijzigd door chielsen op 13-12-2005 19:08 ]

[Woy]

chielsen schreef op dinsdag 13 december 2005 @ 19:07:
Tja tis een beetje een gevoelskwestie. Ik vind het niet echt belangrijk genoeg om voor al die opties apart een class aan te maken (zal ik dan wel verkeerd hebben), maar ik wil wel graag dat wat ik return een class is die voor welke case ook hetzelfde doet (uitwendig, inwendig dus anders).
Misschien dus toch maar losse classes maken dan.

Ik vind trouwens niks over "Strategy of Policy"

Op de manier dat jij het doet defineer je je classes toch ook? Alleen doe je het dan op de een of andere manier in je functie In een complete OO omgeving zou je zoiets oplossen door bijvoorbeeld een Interface te defineren en dan een Instance van een class te returnen die die interface implementeerd. De aanroepende code hoeft dan voor de rest niet te weten welke class het is die de juiste code implementeerd want hij heeft een interface waar hij mee kan doen wat hij wilt.

In PHP zou je dus gewoon 2 classes defineren en dan 1 van die 2 classes terug geven.

PHP:

class Test1
{ 
    function Test() { echo 'Hallo'; } 
}; 

class Test2
{ 
    function Test() { echo 'Hallo2'; } 
};

function test( $x) 
{
    switch( $x ){
        case 1:
            return new Test1();
            break;
        case 2:
            return new Test2();
            break;
    }
} 

$obj = test(); 
$obj->test2();

[Michali]

Als je er design pattern achter zet krijg je wel betere resultaten. Voorbeeldje is dit.