[PHP] Functie overschrijven binnen php (module systeem)

[Verwijderd]

Ik ben bezig met een module systeem voor een project. Vroeger (in de wat oudere functies) gebruikte ik het volgende systeem.

PHP:

function module_eenofanderemodulename() { .. }

Dat icm de volgende directory structuur

code:

/modules
/modules/modulename/index.php
/modules/blaat/index.php

Hierdoor is de modulenaam eigenlijk gelijk aan de directorynaam (behalve dat er module_ voor staat). Nou wil ik echter een andere manier bedenken om "ongeveer" het zelfde te kunnen doen.
Een module maakt, adhv verschillende opdrachten, een array:

code:

   $module['return_data'] = array();
   $module['return_data']['naampje'] = 'waardetje';
   $module['return_data']['muhaha'] = '100000';

Nou wil ik een nettere manier hebben dan per module een functie te maken, die ik dan weer aanroep met veel vieze code. Dus ik zat te denken om iets simpels op te zetten met classes. Enkel kan ik geen "nette" manier bedenken hoe ik dit in een module kan verwerken "zonder" dat de gebruiker (het persoon dat de module maakt) rekening moet houden met functienamen (wat in het oude systeem wel het geval was). Dus ik probeer iets op te zetten wat dus altijd goed werkt. Ik heb alleen geen idee hoe ik dat moet aanpakken.

Ik kan iets doen als:

PHP:

$func = array();
$func[] = "function a() { echo 'blaat'; }";
$func[] = "function a() { echo '1234'; }";
eval($func[0]);
eval($func[1]);

Dat werkt natuurlijk niet, dus ik zat meer te denken om een functie te gaan extenden binnen een class. Maarja wat zijn de voordelen en wat zijn de nadelen. Hoe kan ik dit het beste aanpakken?
Ik zou de modules zo kunnen opbouwen dat hij het zonder functies/classes doet, maarja mischien zitten daar ook weer nadelen aan. Ik heb in ieder geval geen idee hoe ik dit het "beste" kan aanpakken.

Het doel is (simpel gezecht): Ik heb 1 bestand, zodra ik dat include dan moet hij (op een of andere manier) iets toevoegen aan een array (ongeacht de oproep methode). Wat kan ik het beste doen?

[chuxiej]

Je kan toch gewoon in het include bestand de class al aanroepen met $var = new class;
En dan in de class een constructor maken (functie met zelfde naam als de class) die automatich wordt aangeroepen en die dan de array defineerd.

Sorry als ik het fout heb of je vraag niet goed begrijp.

[Verwijderd]

Het probleem is dat ik een "onbeperkt" aantal modules heb, en moet dus de class overschrijven. Dat is een probleem, want hij gaat zeuren dat de class al bestaat. Het idee wat ik heb hoeft niet verplicht een class te zijn die ik kan aanroepen, alles is eigenlijk wel goed, als de naamgeving binnen de bestanden maar het zelfde blijft.

[NMe]

Kun je niet op de een of andere manier iets beginnen met create_function(), en daarna werken met functie-pointers?

[ Voor 13% gewijzigd door NMe op 15-01-2005 02:55 ]

[Verwijderd]

-NMe- schreef op zaterdag 15 januari 2005 @ 02:54:
Kun je niet op de een of andere manier iets beginnen met create_function(), en daarna werken met functie-pointers?

Ik denk dat dit perfect gaat werken, ik ga kijken hoe ik dit kan verwerken. Het ziet er op het eerste gezicht goed uit.

[Grijze Vos]

Je wou het minder ranzig doen? En dan ga je met dat soort functies aan de slag.

[Verwijderd]

Grijze Vos schreef op zaterdag 15 januari 2005 @ 13:30:
Je wou het minder ranzig doen? En dan ga je met dat soort functies aan de slag.

Ja dat is zo, maar een simpelere manier heb ik nog niet gezien

[Mithrandir]

Waarom laat je iedere module niet een aparte class worden?

PHP:

class mod_modulenaam
{
  function iedereNAAAM()
  {
    echo("dit werkt toch prima? Zonder dat je problemen hebt met namen enzo");
  }
}

Dus wat is je punt?

[ Voor 6% gewijzigd door Mithrandir op 15-01-2005 13:42 ]

[Verwijderd]

Mithrandir schreef op zaterdag 15 januari 2005 @ 13:41:
Waarom laat je iedere module niet een aparte class worden?

[knip-php]

Dus wat is je punt?

Hierdoor is de modulenaam eigenlijk gelijk aan de directorynaam (behalve dat er module_ voor staat). Nou wil ik echter een andere manier bedenken om "ongeveer" het zelfde te kunnen doen.

Ik zat zelf te denken aan het volgende:

PHP:

$func = create_function('','$a = array();
$a[\'name\']=\'value\';
$a[\'wasd\']=\'123\';
return $a;');
$module_array[] = $func();

Hierdoor heb ik een vaste naam, ipv lelijk gedoe zoals ik het in mijn vorige versies van het project gedaan had.

Ik zou alleen een class gebruiken als ik deze kan extenden, anders gebruik ik wel een functie ipv een class.

[Eärendil]

Verwijderd schreef op zaterdag 15 januari 2005 @ 14:07:Ik zou alleen een class gebruiken als ik deze kan extenden, anders gebruik ik wel een functie ipv een class.

http://nl2.php.net/manual/nl/keyword.extends.php

Je kan van elke module een klasse maken, waarbij je een (of meer) klasse-methodes direct aanroept in je code (bijvoorbeeld doeJeDing() ):

PHP:

class ModuleA {
   var $naampje = 'waardetje';  
   var $muhaha = '100000';

   // deze functie wordt van buiten de klasse aangeroepen
   function doeJeDing() {
       $this->naampje = 'bla';
       return $this->interneFunctie();
   }

   // wordt alleen intern aangeroepen
   function interneFunctie() {
       if ($this->muhaha > 50000) {
           return 'ok';
       } else {
           return 'niet ok';
       }
   }
}

//Je kan deze klasse bijvoorbeeld registreren in een array met:
$modules[] = 'ModuleA';

//aanroepen:
$module = new $modules[x]();
$module->doeJeDing();

//extenden
class ModuleB extends ModuleA {

   // wordt alleen intern aangeroepen
   // overschrijft ModuleA->interneFunctie()
   function interneFunctie() {
       if ($this->muhaha > 10000000000) {
           return 'ok';
       } else {
           return 'niet ok';
       }
   }
}

[Verwijderd]

Dan zit ik dus weer met het volgende probleem: Dan moet ik de naam van ModuleB weten, en dat is dus weer de vaste waarde binnen de include. Die kan ik dus niet kennen, dat moet dus een vaste waarde zijn.
Kan ik op een of een andere manier niet een class verwijderen? class_destroy of iets in die richting?

Ik wil eigenlijk meer naar het volgende:

PHP:

class Main {

  //load other class
  function LoadModule($module_name) {
    //geen idee
  }

  //return data
  //function ReturnModuleData() {
    //dunno
    return $module_data;
  }

  //clear
  function UnloadModule() {
    //blaat
  }

  //constructor
  function Main () {
  }
}

//load and create
$data = array();
$a = new Main();

//include 1st module
include 'modules/1/bla.php';
//load 1st module
$a->LoadModule('bla');
$data[] = $a->ReturnModuleData();
$a->UnloadModule();

//load 2nd module
include 'modules/lol/module.php';
$a->LoadModule('lol');
$data[] = $a->ReturnModuleData();
$a->UnloadModule();

De include mag geen vaste namen bevatten, dus lol en bla ($a->LoadModule).

PHP:

class Module {
  //naam zal mn worst wezen, is aan de gebruiker, maar ik wil alleen door de aanroep
  //van de class (dus door de constructor) mijn data terugkrijgen.
  function ...... () {
  }

  function Module() {
    //
  }
}

Iedere include heet dus de class Module (of hoe ik het dan ook opzet), wat daar binnen gebeurt zal mij een worst zijn.

Al zo door hier te typen bedenk ik me net het volgenden, is dat niet goed te gebruiken of is dat te "vies"?

PHP:

$data = array();
include 'file.php';
include 'file2.php';
//---------------------- file.php hier onder
class classje_functienaam {
  function classje_functienaam() {
    //hier doet de user zelf maar wat hij wil, boeiend, zolang het binnen de class blijft zal
    //het mij een worst zijn.
  }
  function returndata() {
    return array('val'=>'muha','iets=>'niets');
  }
}
$tmp = new classje_functienaam();

$data[] = $tmp->returndata();
//---------------------------file.php hier onder
class classje_iets {
function classje_iets() {
//hier doet de user zelf maar wat hij wil, boeiend, zolang het binnen de class blijft zal
//het mij een worst zijn.
}
function returndata() {
return array('iets'=>'asd,'tttt=>'12345');
}
}
$tmp = new classje_iets();[/]
$data[] = $tmp->returndata();
Hierdoor heb ik het binnen mijn array, en hoef ik me niet druk te maken om wat de user doet, zolang het maar classje_* blijft (voor de standaard, geen overschrijving van andere dingen). classje verander ik wel in mijn productnaam
Is dit een idee of is dit weer te vies? Ik denk zelf wel dat het werkt, maar dat ben ik.

[ Voor 7% gewijzigd door Verwijderd op 15-01-2005 20:48 . Reden: klein foutje in php code. ]

[Eärendil]

Verwijderd schreef op zaterdag 15 januari 2005 @ 20:42:
Dan zit ik dus weer met het volgende probleem: Dan moet ik de naam van ModuleB weten, en dat is dus weer de vaste waarde binnen de include. Die kan ik dus niet kennen, dat moet dus een vaste waarde zijn.
Kan ik op een of een andere manier niet een class verwijderen? class_destroy of iets in die richting?

Waarom zou je de naam van een klasse niet kennen? Hoe bepaal je dan welke modules je hebt in je systeem? Je kan bijv. alle mappen onder /modules/ modules laten zijn met de naam van de map als module-naam.

De include mag geen vaste namen bevatten, dus lol en bla ($a->LoadModule)

Wat bedoel je hiermee?

Je zou de include toch ook in LoadModule kunnen doen?
Stel je hebt voor elke module een bestand '/modules/ModuleNaam/module.php'. Dat bestand defineert een klasse genaamd ModuleNaam.
Alle module-klassen hebben een functie met een door jou bepaalde naam, bijv. returndata().
Als je LoadModule aanroept met als parameter een modulenaam kan je dus bovenstaand bestand includen, een instantie van de nieuwe klasse maken en daar returndata() op aanroepen

[prototype]

Mijn advies aan jou: OO, Abstraction, Composition, Interface, Inherentence, Adapter/Interpreter/Factory Method Pattern.

[ Voor 3% gewijzigd door prototype op 16-01-2005 18:27 ]