[PHP] functies opslaan in array maar nog niet uitvoeren

[aex351]

Ik ben opzoek naar een manier om eigen functies geschreven in php op te slaan in een array maar nog niet uit te voeren. De array zal dus een lijst met nog uit te voeren php functies en argumenten bevatten.

Is dit mogelijk en zo ja hoe ? kon hier verder geen informatie over vinden.

[ Voor 3% gewijzigd door aex351 op 04-04-2006 23:05 ]

[Maxxi]

Kan je ook uitleggen waarom je dat zou willen?

Ik ben op een gemiddeld nivo php schrijver, maar dit soort grappen heb ik nog nooit nodig gehad.

[XWB]

Ik snap niet wat je wil, een functie wordt pas uitgevoerd wanneer je hem aanroept, wat wil je dan nog meer ?

[Mayco]

al snap ik niet wat je wil bereiken is dit wel mogelijk als je een apparte functie maakt die die array leest, en die vergelijkt met vooraf opgegeven namen dus zoiets als

code:

if (array[1][0] == "nieuwbestand")
  nieuwbestand(array[1][1]);
if (array[1][0] == "verwijderbestand")
  nieuwbestand(array[1][1]);
...

[ Voor 10% gewijzigd door Mayco op 04-04-2006 23:19 ]

[NMe]

Je kan de functienamen en bijbehorende parameters opslaan in een tweedimensionaal array, en het zaakje aanroepen met call_user_func. Maar mij ontgaat het nut een beetje, net als de heren hierboven. Het klinkt alsof je wat erg smerigs van plan bent.

[aex351]

Ik zie dat (bijna) niemand begrijpt waarom ik dit zou willen doen. Heel simpel. Ik heb een buffer met daarin een complete website. Gedurende die buffer run zijn er functies die moeten worden uitgevoert nadat de buffer gestopt is. Deze functies kunnen niet gedurende de buffer run worden uitgevoerd omdat deze functies expliciet bedoeld zijn om de uiteindelijke data in de buffer te bewerken nadat deze gestopt is.

Als simpele voorbeeld : wanneer ik bijvoorbeeld alle letters A op een website veranderd wil hebben in de letter B.

[ Voor 13% gewijzigd door aex351 op 04-04-2006 23:31 ]

[Erkens]

Je kan wel wat prutsen met create_function, maar het is me onduidelijk of dat is wat je zoekt

[prototype]

Volgens mij zoek jij het Command pattern.

[NMe]

aex351 schreef op dinsdag 04 april 2006 @ 23:29:
Ik zie dat (bijna) niemand begrijpt waarom ik dit zou willen doen. Heel simpel. Ik heb een buffer met daarin een complete website. Gedurende die buffer run zijn er functies die moeten worden uitgevoert nadat de buffer gestopt is. Deze functies kunnen niet gedurende de buffer run worden uitgevoerd omdat deze functies expliciet bedoeld zijn om de uiteindelijke data in de buffer te bewerken nadat deze gestopt is.

Als simpele voorbeeld : wanneer ik bijvoorbeeld alle letters A op een website veranderd wil hebben in de letter B.

Dat moet toch wel lukken met de functie die ik aandroeg? In de simpelste vorm althans; het Command Pattern dat prototype aandraagt ken ik niet, dus dat zou wel eens praktischer kunnen zijn.

[prototype]

Nahjah, in z'n essentie gaat het er gewoon om dat je voor elke toelaatbare functie een klasse maakt, die het commando interface implementeert. Zo kan je dus een array bijhouden van commando objecten, en ze op eigen initiatief, e.g. sequentieel aanroepen in een lus. Even wat concreter:

PHP:

interface Command
{
    public function execute();
}

class EenCommandoThingy implements Command
{
    //constructor voor init waarden, of init waarden aan execute overlaten.
    public __construct($params)
    {
        //melp
    }

    public function execute()
    {
        //doe je ding
    }
}

class EenAnderCommandoThingy implements Command
{
    //constructor voor init waarden, of init waarden aan execute overlaten.
    public __construct($params)
    {
        //melp
    }

    public function execute()
    {
        //doe je ding
    }
}

$commandos = array();
$commandos[] = new EenCommandoThingy($params);
$commandos[] = new EenAnderCommandoThingy($params);

foreach ($commandos as $cmd)
{
    if ($cmd instanceof Command)
    {
        ((Command)$cmd)->execute(); // Ik weet niet zeker of je wel mag casten naar iets anders dan een primitieve of Object. Zo nee, dan moet je even de castweghalen, want door dynamictypechecking is aangetoond dat $cmd iig een commando betreft.
    }
}

[ Voor 25% gewijzigd door prototype op 05-04-2006 00:13 ]

[NMe]

Hmm, dat ziet er inderdaad wel praktisch en erg natuurlijk uit. Echter betwijfel ik of het in dit geval handiger is dan het gebruik van call_user_func. Performancetechnisch vermoed ik dat PHP's standaardfuncties iets beter uitpakken.

[crisp]

Wat is dat anders dan bijvoorbeeld zoiets:

PHP:

$commandos = array();
$commandos[] = array( 'function' => 'func1', 'parameters' => array('parm1') );
$commandos[] = array( 'function' => 'func2', 'parameters' => array('parm1', 'parm2') );

foreach($commandos as $commando)
{
    call_user_func_array($commando['function'], $commando['parameters']);
}

?

[prototype]

crisp schreef op woensdag 05 april 2006 @ 00:01:
Wat is dat anders dan bijvoorbeeld zoiets:

PHP:

$commandos = array();
$commandos[] = array( 'function' => 'func1', 'parameters' => array('parm1') );
$commandos[] = array( 'function' => 'func2', 'parameters' => array('parm1', 'parm2') );

foreach($commandos as $commando)
{
    call_user_func_array($commando['function'], $commando['parameters']);
}

?

Dat die opstelling niet in java / C# mag, zoals ik dat gewend ben

-NMe- schreef op woensdag 05 april 2006 @ 00:01:
Hmm, dat ziet er inderdaad wel praktisch en erg natuurlijk uit. Echter betwijfel ik of het in dit geval handiger is dan het gebruik van call_user_func. Performancetechnisch vermoed ik dat PHP's standaardfuncties iets beter uitpakken.

Hehe, ik denk dat schaalbaarheid zwaarder meeweegt dan performance, onder reeele omstandigheden. Natuurlijk is het performance technisch beter om PHP's standaard functies te gebruiken, maar deze methode biedt een eenvoudig mechanisme om commando's toe te voegen, waarbij je niet in een lijstje even bij hoeft te houden welke het nou precies allemaal zijn zoals crisp doet; dat is natuurlijk ook errorprone, aangezien die parameters gewoon valid tijdens compiletime zijn, maar tijdens runtime _niet per definitie_. Bij de command pattern instance je commando objecten en alles is tijdens compiletime te evalueren, i.e. een beetje IDE vist dit er direct uit Scheelt je dus ook nog overhead tijdens development

[ Voor 61% gewijzigd door prototype op 05-04-2006 00:19 ]

[FTPlus]

Ik ben toevallig bezig met netzoiets. Ik gebruik hiervoor een aantal nested classen waarmee ik de site opbouw. Als alles uitgevoerd is word de site pas naar de uitgang buffer geschreven.

om een tipje van de sluier op te lichten:

PHP:

class page {
public $class = Array(); //hier komen alle elementen in die geschreven moeten worden

function Write()
{
    foreach ($this->class as $class)
    {
        $class->Write();
    }
}

function __destruct()
{
    $this->Write();
}

}

een andere leuke manier om dynamische functies te maken is overloaden:

PHP:

class foo {

function __call($name, $parram)
{
    switch($name)
    {
    case 'bar':
    echo $parram[0];
    break;
    case 'bar2':
    echo join(', ', $parram);
    break;
    default:
    echo "Unknown function: $name";
    break;
    }
}

}

$obj = new foo;
$obj->bar('Test'); //Test
$obj->bar2('appel', 'banaan', 'peer'); //appel, banaan, peer
$obj->blaat(); //Unknown function: blaat

ik hoop dat het nuttig is, ik weet namelijk niet precies wat je wil gaan doen

[ Voor 8% gewijzigd door FTPlus op 07-04-2006 01:42 ]

[T-MOB]

FTPlus schreef op vrijdag 07 april 2006 @ 01:40:
Ik ben toevallig bezig met netzoiets. Ik gebruik hiervoor een aantal nested classen waarmee ik de site opbouw. Als alles uitgevoerd is word de site pas naar de uitgang buffer geschreven.

om een tipje van de sluier op te lichten:

PHP:

class page {
public $class = Array(); //hier komen alle elementen in die geschreven moeten worden
//....

Als het hier om een website gaat vind ik dit een vreemd ontwerp. Als ik het goed begrijp geef je elk element van de pagina nu een Write() methode die de output levert. Als de layout verandert mag je dus voor al die elementen de Write() methode gaan aanpassen. Hierdoor is de code vrij slecht onderhoudbaar.
Een imho logischere invulling voor een "pagina object" is dat je aan de ene kant zorgt dat de gewenste data beschikbaar wordt en aan de andere kant zorgt dat het juiste template om die data weer te geven wordt gebruikt. Maar goed, allicht begrijp ik je verkeerd...

[prototype]

Belangrijker, de opzet van FTPlus gaat fout wanneer een element uit de array $class niet een methode Write() ondersteund; hier zijn natuurlijk interfaces voor bedacht voor typeren en specificeren van members.

[FTPlus]

prototype schreef op vrijdag 07 april 2006 @ 02:37:
Belangrijker, de opzet van FTPlus gaat fout wanneer een element uit de array $class niet een methode Write() ondersteund; ...

De modules die ik in de array laad zijn allemaal voortboorduurt op een default class, die natuurlijk de write functie bezit.

@T-MOB :
De pagina layout gebeurt op een ander niveau van het script. Dit geeft enkel de stuctuur weer, ofwel de juiste volgorde.

[Grijze Vos]

Volgens mij kan dit zelfs ook:

PHP:

<?

  function funky()
  {
    echo "funkeh!";
  }

  $test = "funky";

  $test();
?>

(testen...)

Ja, kan idd.

code:

(greyfox@bierenfriet)~/test $php test2.php
funkeh!

[aex351]

Grijze Vos schreef op zaterdag 08 april 2006 @ 04:27:
Volgens mij kan dit zelfs ook:

PHP:

<?

  function funky()
  {
    echo "funkeh!";
  }

  $test = "funky";

  $test();
?>

(testen...)

Ja, kan idd.

code:

(greyfox@bierenfriet)~/test $php test2.php
funkeh!

Moet dit iets speciaals voorstellen ofzo

[NMe]

Ja, want het doet precies wat jij wil? Hij geeft aan dat je de naam van een functie kan opslaan in een variabele, en vervolgens $variabelenaam() kan aanroepen. Echter heb je in dit geval een probleem met een variabel aantal parameters.

Anyway, als je een voorbeeld niet begrijpt kun je dat ook iets vriendelijker brengen hoor.

[Swerfer]

aex351 schreef op dinsdag 04 april 2006 @ 23:29:
Ik zie dat (bijna) niemand begrijpt waarom ik dit zou willen doen. Heel simpel. Ik heb een buffer met daarin een complete website. Gedurende die buffer run zijn er functies die moeten worden uitgevoert nadat de buffer gestopt is. Deze functies kunnen niet gedurende de buffer run worden uitgevoerd omdat deze functies expliciet bedoeld zijn om de uiteindelijke data in de buffer te bewerken nadat deze gestopt is.

Als simpele voorbeeld : wanneer ik bijvoorbeeld alle letters A op een website veranderd wil hebben in de letter B.

Ik programeer zelf in asp.net, waarbij je een override sub render kunt gebruiken om de gegenereerde html te ondervangen voordat deze naar de client wordt gestuurd. Deze html kan je dan aanpassen zoals je zelf wilt om vervolgens pas naar de client te sturen.

Ik weet niet of zoiets in PHP bestaat, maar dit asp.net scenario verduidelijkt misschien wel jouw probleem waarmee anderen jou kunnen helpen.

[aex351]

-NMe- schreef op zaterdag 08 april 2006 @ 20:01:
Ja, want het doet precies wat jij wil? Hij geeft aan dat je de naam van een functie kan opslaan in een variabele, en vervolgens $variabelenaam() kan aanroepen. Echter heb je in dit geval een probleem met een variabel aantal parameters.

Anyway, als je een voorbeeld niet begrijpt kun je dat ook iets vriendelijker brengen hoor.

Bedoelde niets verkeerds met mijn reply, misschien dat dat wel zo op jou overkomt.

Ik wist niet dat dat mogelijk was een var als functie aan te roepen waarbij de inhoud van de var de functie naam is. Zou dit geen beveiligings probleem in zijn algemeenheid naar voren kunnen roepen ?

Verder vind ik call_user_func nog steeds de mooiste oplossing.

[NMe]

Swerfer schreef op zaterdag 08 april 2006 @ 21:25:
Ik programeer zelf in asp.net, waarbij je een override sub render kunt gebruiken om de gegenereerde html te ondervangen voordat deze naar de client wordt gestuurd. Deze html kan je dan aanpassen zoals je zelf wilt om vervolgens pas naar de client te sturen.

Ik weet niet of zoiets in PHP bestaat, maar dit asp.net scenario verduidelijkt misschien wel jouw probleem waarmee anderen jou kunnen helpen.

PHP kent dat ook wel hoor. Output control.

aex351 schreef op zaterdag 08 april 2006 @ 21:26:
Bedoelde niets verkeerds met mijn reply, misschien dat dat wel zo op jou overkomt.

Mooi, gelukkig. Dan heb ik niets gezegd.

Ik wist niet dat dat mogelijk was een var als functie aan te roepen waarbij de inhoud van de var de functie naam is. Zou dit geen beveiligings probleem in zijn algemeenheid naar voren kunnen roepen ?

Zolang je die string zelf genereert en niet van de gebruiker afkomt lijkt het me geen enkel beveiligingsrisico. Als dit wel zo was, dan had je datzelfde risico ook gehad met call_user_func.

Verder vind ik call_user_func nog steeds de mooiste oplossing.

Mooier is het niet per se, maar wel uitgebreider/handiger, aangezien het aantal parameters van de functie daarmee variabel mag zijn.

[Grijze Vos]

Mja, het "leuke" is dus dat je datzelfde geintje ook met classes kunt doen. Zo kun je bijvoorbeeld aan de hand van een variabele een verschillende subclass van je parsers instantieren. Best handig.

[Michali]

Ik zou zeker voor de Command pattern oplossing gaan. Die is een stuk netter dan functies imo. Je wilt hier duidelijk polymorphisch gedrag nabootsen met functies, waarom dan niet gelijk met het mechanisme dat ervoor ontworpen is? Het mooie van die Commands is dat je de parameters niet op moment van aanroepen meegeeeft, maar bij het initialiseren van het object. Daarna hoef je je er niet meer druk om te maken en kun je hem overal aanroepen waar je wilt.