So wird es nicht funktionieren. Du kannst kein include direkt innerhalb einer Klasse einsetzen. Die einfachste Möglichkeit neue Funktionen zu deinem Skript hinzuzufügen ist alle Dateien eines Pluginverzeichnises einzubinden. (außerhalb einer Klasse) damit kannst du neue Funktionen und neue Klassen aufnehmen, jedoch keine bereits vorhandenen Klassen erweitern. Du hast jedoch die Möglichkeit durch Vererbung Klassen zu definieren, die deine bereits vorhandenen Klassen erweitern, wobei du dann aber, um die neuen Methoden nutzen zu können, immer Instanzen der neuen Klasse benutzen musst.
Beispiel 1 Datei 1:
PHP:
include('plugins/newclass.php');
class test {
function hallowelt() {
echo "hallo Welt!";
}
}
Ist wie man sieht eine ganz einfache Klasse.
Beispiel 1 Datei 2:
PHP:
class testmore extends test {
function halloplugin() {
echo "hallo Plugin!";
}
}
Willst du jetzt die neue Methode halloplugin verwenden, musst du
PHP:
$objTest = new testmore();
$objTest->halloplugin();
anstatt
PHP:
$objTest = new test();
$objTest->halloplugin();
verwenden. Letzteres würde zu einem Fehler führen, da in der Klasse Test ja keine Methode halloplugin existiert.
Ich nehme aber mal stark an, du möchtest gerne das je nach Plugin neue Methoden zur bereits vorhandenen Klasse hinzugefügt werden.
Möglichkeit 1: Die Plugins ersetzen die vorhandenen Klassen vollständig. D.h. du bindest je nachdem ob ein Plugin vorhanden ist oder nicht, entweder die PHP Datei aus dem Plugin oder aus dem Hauptprogramm ein.
Möglichkeit 2: Die Klasse erweitert sich selbsttätig.
Beispiel 2 Datei 1:
PHP:
class test {
function test() {
// Verzeichnis öffnen
$dir = dir('plugins/test/');
// Jede Datei im Verzeichnis durchlaufen
while($file = $dir->read()) {
// Unerwünschte Elemente ausschließen
if($file!='.' && $file!='..') {
include('plugins/test/'.$file);
}
}
}
function hallowelt() {
echo "hallo Welt!";
}
}
$objTest = new test();
$objTest->plugin();
Der Konstruktor der Klasse test prüft selbst nach, ob Plugins verfügbar sind, und falls dem so ist, werden diese eingebunden. Das echte Geheimnis liegt in der Datei 2. Denn ansonsten gibt es hier nur die kleine hallowelt Funktion.
Beispiel 2: Datei 2:
PHP:
class extTest extends test {
function plugin() {
echo "Plugin bereit!";
}
}
$this = new extTest();
In der Plugindatei wird eine Klasse definiert, welche die von der eigentlichen Klasse erbt. Das ist wichtig, damit alle Methoden aus der ersten Klasse auch weiterhin zur verfügung stehen. Zusätzlich definiert die Klasse die neue Methode plugin(). Durch die Zeile $this = new extTest(); wird nun die neue Klasse instanziert und überschreibt das alte Objekt. Somit steht ab jetzt unter dem alten Bezeichner ($objTest) auch die neue Methode zur Verfügung.
Einen kleinen Haken hat die Sache allerdings so noch: Es kann immer nur eine Plugindatei verwendet werden. Man könnte jetzt zwar in jedem Plugin prüfen ob es "übergeordnete" Plugins gibt, von denen dann zu erben ist, dies ist aber wenig praktikabel und höchst Fehleranfällig.
Das ganze würde natürlich nur gebraucht, wenn du wirklich vorhast deine Plugins aus dem Hauptprogramm aufzurufen und zu verwenden, was generell eine schlechte Architektur der Software ist. Besser ist es, wenn die Plugins in sich abgeschlossen sind. Also das dein Hauptprogramm selbst keine der Funktionen, Klassen benutzt, die du als Plugin bereitstellst.
Z.B. wenn du ein CMS hast und willst dort eine Anzeige für die Besucher, die online sind, einbauen. Jetzt dem Hauptskript zu sagen: "Sieh nach, ob das Besucherzählplugin da ist und wenn ja führe die Funktionen aus." ist schlecht. Besser ist dem Hauptskript zu sagen: "Sieh nach ob es irgendein Plugin gibt, führe es aus und nehme das Ergebnis und füge es ein." ist sinnvoller. Du würdest im letzteren Fall mit einer Schnittstelle arbeiten.
) am geschicktesten gestaltet, dass es durch Plugins erweitert werden kann. Sowas wie