[PHP] Voorkomen van duplicaten

[Priet]

Ik ben bezig met een website waarmee je de functionaliteit kan uitbreiden met modules.
Een module is in feite niets anders dan een los php bestand dat bestaat uit enkele functies. Elke module heeft dezelfde functies zodat de website altijd weet hoe het de modules aan moet spreken. Het krijgt dan ook telkens dezelfde outputvorm terug.

Je kunt niet twee functies maken met dezelfde naam en dezelfde samenstelling van parameters (in PHP ook niet met verschillende parameters). Dat is in principe geen probleem voor de website, aangezien er normaal gesproken maar één module tegelijk geladen wordt (dmv een include()).

Maar op een gegeven moment moet ik twee modules tegelijktijd ingeladen hebben. Dat gaat dus niet want dat levert een 'already declared function' error (ofzoiets) op, want de functies zouden dan dubbel voor komen...

Dat is dus mijn probleem Ik ben nu op zoek naar een manier om de modules op de een of andere manier toch uit elkaar te houden. Ik heb enkele oplossingen bedacht:

Alle functienamen vooraf laten gaan door de bestandsnaam van de module. De functies kun je dan aanroepen door een trucje in PHP:

PHP:

function sayHello () {
  print "Hallo!";
}

sayHello();
$groet = 'sayHello';
$groet();

Dit levert dus twee keer de output 'Hallo' op. Dit zou ik kunnen gebruiken om de methodes van een module aan te roepen, maar het brengt per aanroep wel een extra aantal stappen met zich mee.

Een andere oplossing zou kunnen zijn om ditzelfde te doen maar dan met classes. De modules herschrijf ik dan naar een classe zodat daar steeds een instantie (object) van gemaakt moet worden voordat de functies aangeroepen kunnen worden. Als nu die classenaam voor elke module anders is (ipv de functienamen) hoef ik veel minder te herschrijven.
Maar ik vraag mij af of bovenstaande 'truc' met functies ook mogelijk is met classes. Het zou veel minder werk zijn om dat te veranderen dan alle functienamen te vervangen.

Voor degenen die mijn verhaal tot hier nog hebben kunnen volgen: is dit mogelijk is, en zo ja: hoe?

[ Voor 5% gewijzigd door Priet op 30-05-2004 12:41 ]

[ACM]

Ilk zou het sowieso in klassen gaan omzetten, maar of die bovenstaande truc ook op die manier mogelijk is? Sowieso met call_user_func en eval natuurlijk.

[Michali]

Je geeft eigenlijk al zelf de antwoorden. In een situatie als deze denk ik dat je toch het beste met classes kunt werken. Wat ik overigens wel afvraag is of je wel functies nodig hebt in de module bestanden. Zou je mischien een beetje kunnen toelichten wat de taak van die functies dan zijn (nieuwsgierig ). Ik werk zelf ook wel met modules maar ik heb vrijwel nooit functies nodig. Ik schrijf alle uitvoerbare code gewoon direct in het bestand en die laat ik dan includen.

en voor je eerste oplossing zou je ook iets als dit kunnen doen:

PHP:

<?php

function func1()
{
    print "a";
}

function func2()
{
    print "b";
}

$functions = array();

function register_functions($a, $b)
{
    global $functions;
    $functions[] = array ( 'a' => $a, 'b' => $b );
}

register_functions('func1', 'func2');

foreach($functions as $index)
{
    $index['a']();
    $index['b']();
}

?>

Ik weet alleen niet in hoeverre dit echt bruikbaar is.

[Verwijderd]

misschien is dit niet wat je wilt maar je kunt lijkt mij gewoon de module openen en dan met find & replace het woordt function vervangen voor function bestandnaam_ dan maakt hij van function sayHello () bijvoorbeeld function bestand_sayHello (). dit lijkt me dan niet zo veel werk kosten

[Priet]

Met die call_user_func() is het in theorie mogelijk, al vind ik het niet zo mooi.
Dit voorbeeld kwam ik op de hierboven aangegeven link tegen:

PHP:

class myclass {
  function say_hello() 
  {
   echo "Hello!\n";
  }
}

$classname = "myclass";

call_user_func(array($classname, 'say_hello'));

Dus daar zou het mee moeten lukken.

Maar ik heb liever dat je gewoon de volgende werkwijze aan kunt houden:

PHP:

$module = new ModuleClass();
$module->doeIetsLeuks("Hallo");

Het gaat er nu dus om de naam van die classe te veranderen aan de hand van bijv. de bestandsnaam. ModuleClass moet dus iets als een variabele kunnen zijn (zoals dus met functies kan).

@Michali: Ter uwe info, de functies waar een module over moet beschikken zijn:

PHP:

function constructModule($groep_id, $base_url)
function newModuleInstance($groep_id, $groep_naam)
function removeModuleInstance($groep_id)
function geefModuleAfdelingen($groep, $rubriek)
function geefModuleAfdelingen_url($schooljaar, $groep, $rubriek = NULL)
function geefModuleTools()
function geefModuleInfo($subject)

De methode die ProFox aangeeft (Search & Replace) zou natuurlijk wel kunnen, maar dan moet je ook nog eens alle aanroepen gaan veranderen. En juist díe verandering is mij eigenlijk ietsje teveel, omdat er bij elke aanroep een paar extra stappen in beeld komen.

[ Voor 4% gewijzigd door Priet op 30-05-2004 14:36 ]

[Priet]

Ik kwam hier een voorbeeld tegen, en volgens mij is dit wat ik nodig zou moeten hebben:

PHP:

$globalObj;

class tClass
{
   function &instance()
   {
       global $globalObj;
       if(!is_object($globalObj))
       {
           $globalObj = new tClass();
       }
       return $globalObj;
   }
}

$classname = "tClass";
# calling the function this way won't 
# return a reference.
$test = &call_user_func(array($classname,"instance"));
# but if we call it again with the instance
# that we just got, it'll be the right
# one
$test = &$test->instance();
# so test is now a reference to $globalObj, just like it should be

# let's verify it:
$test->blah=1;

echo "<pre>";
print_r($test)."\n";
print_r($globalObj);
echo "</pre>";
# there, now it behaves just like you'd expect

Moet ik alleen de naam van die global variabele veranderen, anders krijg ik alsnog hetzelfde gezeur dat er iets is dat al bestaat.

Kan iemand uitleggen waarom die & voor de functienaam instance staat en waarom dat dan ook weer voor $test moet komen te staan? Heeft dit iets te maken met de reference die wordt teruggegeven?

[Johnny]

Ik heb het dubbel includen een keer opgelost door include_once() te gebruiken in plaats van include().

[Priet]

@Johnny: Dat is totaal niet van toepassing

Ik ben er achter: het kan ook gewoon zo:

PHP:

include("modules/contactformulier.mod.php");
$naam = "ContactFormulier";
$module = new $naam();

Op deze manier kan ik dus twee verschillende classes aanmaken die ieder wel dezelfde functies bevatten
Ik ga dit nog even goed testen.

Met dank aan ieders hulp.

[Verwijderd]

Misschien een idee om function_exists() te grebruiken?

[Priet]

En dan? Ik weet van tevoren al dat die functies zullen bestaan als ik twee keer probeer een module te laden...

[Reggino]

Je zou het gewoon echt object georienteerd moeten oplossen. Ik vind je oplossing geen mooie workaround, daar krijg je later weer problemen mee...

[ Voor 78% gewijzigd door Reggino op 31-05-2004 09:28 ]

[Priet]

Ik doe het nu toch OO? Ik geef de klasses gewoon telkens een andere naam, moet toch kunnen

Begrijp me niet verkeerd: ik zou graag willen weten wat ik eventueel verkeerd aanpak!