[PHP] Code die bij elke functie aanroep uitgevoerd wordt

[Burat]

Is het mogelijk in PHP om een function of expressie te definieren die bij elke aanroep van zelfgedefinieerde functies uitgevoerd wordt?

Dus: Je maakt een klasse met 5 functies, en je wilt dat bij elke aanroep van een functie in die klasse "iets" gedaan wordt.

[D2k]

hmmz das een goeie
een constructor werkt alleen bij het aanmaken van de klasse

ik denk dat je het zelf zal moeten fixxen, want een standaard oplossing zie ik zo 1-2-3 niet

[Tux]

Hmm.. is het niet mogelijk een soort functie te maken met je standaardcode die weer een functie uit een class oproept dan

[whoami]

Burat schreef op 24 september 2002 @ 10:05:
Is het mogelijk in PHP om een function of expressie te definieren die bij elke aanroep van zelfgedefinieerde functies uitgevoerd wordt?

Dus: Je maakt een klasse met 5 functies, en je wilt dat bij elke aanroep van een functie in die klasse "iets" gedaan wordt.

#define iets.

Is die iets telkens hetzelfde?

[drm]

Burat:
Dus: Je maakt een klasse met 5 functies, en je wilt dat bij elke aanroep van een functie in die klasse "iets" gedaan wordt.

Dat lijkt me niet meer dan logisch

Ik denk dat je met zoiets een eind komt:

PHP:

class Base { 
   var    $a; 

   function Base () { $this->a = 0; } 
   function voorAlleFuncties () { $this->a ++; } 
} 

class Sub extends Base { 
   function Sub () { Base::Base (); } 
   function functie1 () { 
      Base::voorAlleFuncties (); 
      echo "woei!\n"; 
   } 
   function functie2 () { 
      Base::voorAlleFuncties (); 
      echo "woei en nog eens woei !\n"; 
   } 
   function functie3 () { 
      Base::voorAlleFuncties (); 
      echo "\$this->a is nu: {$this->a}\n"; 
   } 
}

$s = new Sub ();
$s->functie1();
$s->functie2();
$s->functie3();

Om echt vast te leggen dat voor elke functie een bepaalde aanroep moet gebeuren denk ik niet dat je een oplossing vindt (tenzij je met hele gore eval-constructies gaat werken, maar doe dat alsjeblieft niet )

hth

edit:
[list]____________________
[b]whoami:[/b] #define iets.[/list]C, C++ PHP

[Burat]

Wat ik bijv. zou willen is bij elke functie die aangeroepen wordt, deze aanroep loggen. Dus:

PHP:

Class Logger
{   var stack;
    function Logger()
    {
    }
    
    function addToStack($str)
    {   $this->stack[] = $str;
    }
}

Logger l = new Logger();

Class TestLogger
{   function TestLogger()
    {   $GLOBALS["l"]->addToStack(__FUNCTION__);
        $this->init();
    }
    
    function init()
    {   $GLOBALS["l"]->addToStack(__FUNCTION__);
        $this->doIt();
    }
    
    function doIt()
    {   $GLOBALS["l"]->addToStack(__FUNCTION__);
    }
}

TestLogger t = new TestLogger();

[Burat]

drm: ik wil het dus zo hebben dat ik NIET bij elke functie "Base::voorAlleFuncties ();" moet toevoegen

Dus dat je 1 keer definieert dat bij elke functie (Base::voorAlleFuncties ();) moet worden aangeroepen.

[drm]

Ik ben bang dat dat je niet gaat lukken

[Burat]

Jammer.. dat dacht ik al. Ik hoopte dat er een soort "register_shutdown_function() / register_tick_function()" was waar ik al tijden overheen kijk in de manual...

[drm]

hm * drm kende declare niet eens
zou kunnen dat er dan een workaround is te verzinnen...

[stekkel]

Misschien kan je iets doen met register_tick_function.

edit:

te laat

[ Voor 0% gewijzigd door stekkel op 24-09-2002 10:25 . Reden: te laat ]

[chem]

Je kan dit wel 'extern' doen via een aparte PHP module die je in C schrijft en de Zend optimizer evt. vervangt.
Er zijn daar al tools voor, die voor elke regel (!) het aantal ms. wegschrijft en je dus je script kan analyseren.

deze bv.: http://www.pm9.com/newpm9/itbiz/php/phpdyn/index.php

[Aetje]

Tja, 'k heb weinig verstand van PHP... Maar in Delphi zou je de constructor van TObject aan kunnen passen
Elk nieuw component wat dan gecreerd wordt, krijgt sowieso de contructor van de ultieme ancestor class (TObject) mee.

[mbravenboer]

Je hebt er niets aan, maar even ter informatie: wat jij wilt is Aspect geOrienteerd Programmeren (AOP). Dit is een paradigma wat aardig in opkomst is en eigenlijk een soort uitbreiding van het OO paradigma is. Het maakt een extra onderscheid in aspecten, waarbij je deze aspecten op te bepalen plaatsen in je code kan laten 'weven'.

Voor Java kan je gebruik maken van AspectJ als je aspect georienteerd programmeren wilt toepassen. Ik vermoed dat er nog niemand op de gedachte is gekomen om een aspect georienteerde uitbreiding voor PHP te maken, maar dat je weet maar nooit .

[mbravenboer]

Een paar artikelen over AspectJ en AOP

Improve modularity with aspect-oriented programming

I want my AOP

Aspect Oriented Programming

en natuurlijk de site:

http://www.aspectj.org/

[Burat]

mbravenboer: Wow! Das idd precies wat ik zoek. Dat eerste artikel is een grote aha-erlebnis .

[mbravenboer]

Het was voor mij inderdaad ook grappig om te lezen hoe jij precies op zoek was naar dit concept .

Zo zie je maar dat je naar aanleiding van dergelijke vragen misschien wel hele goede ideeen op kan doen .

[Burat]

Kunnen wij met P&W dat niet oppakken en met z'n allen een AOP PHP maken? Vooral in een webomgeving zijn dingen als logging, contextgevoelige errors enzo - duidelijke AOP functies - erg nuttig..

[mbravenboer]

Burat: Kunnen wij met P&W dat niet oppakken en met z'n allen een AOP PHP maken?

Het zou inderdaad heel aardig en nuttig zijn, maar onderschat de hoeveelheid werk die voor een niet triviale implementatie (met functionaliteit richting die van AspectJ gaat) vooral niet.

Ik zie hem hier: http://aosd.net/tools.html in ieder geval nog niet bijstaan . Merk overigens op dat er ondertussen dus al veel meer tools zijn dan alleen AspectJ .

[Burat]

Ik heb even wat geprobeerd met declare en register_tick_function():

PHP:

function logTick($f, $l)
{   $GLOBALS["debuglog"]->trace($f, $l, "", "", ""); 
}

register_tick_function("logTick", __FILE__ , __LINE__);

declare (ticks=1)
{   
 ...
}

Dit werkt alleen niet, omdat bij het registeren van de functie de argumenten al worden vastgelegd. In de log komt dus elke keer de regel/file van register_tick_function binnen. Dit is niet op te lossen denk ik. Je kan hier geen eval() kan gebruiken (omdat dan line: 1 van eval wordt gebruikt). Ook kan je geen references naar constanten kan maken, anders zou misschien een reference naar __FILE__ meegeven aan register_tick_function werken.