[nox]

Hi,

zunächst mal vorweg, ich rede nicht von register_globals!

Also meine Frage ist ganz einfach, vielleicht hat der ein oder andere schon Erfahrungen gemacht. Ich schreibe gerade an einem System indem ich eine Variable (bsp. $XY). Diese Variable ist ein Objekt welches unteranderem die Datenbank Verwaltung und Smarty (Templatesystem) enthält.

Jetzt fragen sich wahrscheinlich die ersten, wozu das ganze? Ganz einfach ich möchte das ganze System etwas "Zentralisieren". Vor allem in Klassen und Funktionen ist es doch schneller "global $XY" als "global $Smary, $db, $mail....".

So jetzt denke ich mir hmm doch recht Praktisch, aber wahrscheinlich wird diese Variable doch recht viel Speicher fressen. Wie sieht es aus? Jemand Erfahrungen oder ist meine Sorge unbegründet?!

Gruß nox

[Flor1an]

Wieso sollte die Variable "Speicher" fressen. Bei Objekten sind es nur Zeiger auf die entsprechenden Stellen wo das Objekt im Speicher liegt. Dass sollte so oder so nicht das Problem von globalen Variablen sein.

Funktionieren tuts auch. Aber das Problem ist wenn irgendwo mal eine dieser Variablen überschrieben wird wars das. Und bis du solche Fehler findest kann es teilweise etwas länger dauern ... musst ich selbst mal am eigenen Leib erfahren als ich ein bestehendes System etwas erweitern sollte und es globale Variablen gab die ich allerdings nicht kannte da diese nirgendwo dokumentiert waren.

Eine Möglichkeit wäre das Factory Pattern. Bedeutet du hast eine Klasse die als Singleton fungiert und die ganzen "globalen" Variablen beinhaltet.
Das bedeutet diese Klasse ist statisch, es kann also immer nur das zuerst initialisierte Objekt aufgerufen werden. In diesem Objekt speicherst du jetzt die anderen Objekte, also DB, Smarty, Mail etc.

Wenn du jetzt in irgend einer Klasse eine andere Aufrufen möchtest kannst du das so z.B. lösen:

PHP-Code:

<?php
class Smarty {
    public function tu_was_mit_der_db() {
        $db = FactoryClass::getInstance()->get('db');
        $db->query(...);
    }

}

Du kapselst also alle globalen Variablen in der FactoryClass. So kann man Variablen nur noch überschreiben wenn man explizit die FactoryClass dazu auffordert. Es kann also nicht mehr aus versehen passieren.

[nox]

Danke für deine Antwort!

Die Idee mit der FactoryClass finde ich klasse, werde mich später mal dranbegeben!

Danke nochmal und Gruß nox

[Jojo]

Falls dich eine zweite Meinung interessiert:
Ich versuche ebenfalls globale Variablen wenn möglich zu meiden (aus o.g. Gründen und aus Sauberkeit) und benutze lieber Singleton.
Übrigens kann man mit Singleton, get und set ganze nette Config-Klassen erstellen, bei denen Konfigurationsklassen rauskommen, mit denen man dann wie folgt auf einzelne Werte zugreifen kann:

PHP-Code:

$Config->mysql->user = "root"; 


Nur so als Anmerkung

[nox]

Zitat von Jojo

Falls dich eine zweite Meinung interessiert:
Ich versuche ebenfalls globale Variablen wenn möglich zu meiden (aus o.g. Gründen und aus Sauberkeit) und benutze lieber Singleton.
Übrigens kann man mit Singleton, get und set ganze nette Config-Klassen erstellen, bei denen Konfigurationsklassen rauskommen, mit denen man dann wie folgt auf einzelne Werte zugreifen kann:

PHP-Code:

$Config->mysql->user = "root"; 


Nur so als Anmerkung

Hmm, das ist eigentlich genau wie mein Lösungsansatz. Mit Singleton habe ich zuvor noch nie gearbeitet. Wo genau liegt der Unterschied?

Danke für deine Antwort

Gruß nox

[Jojo]

Zitat von nox

Mit Singleton habe ich zuvor noch nie gearbeitet. Wo genau liegt der Unterschied?

Singletons zeichnen sich dadurch aus, dass es nur eine Instanz zur Laufzeit gibt.
d.h. man kann bspw. in Teil A eines Scriptes in der Instanz einen Wert speichern und in Teil B diesen Wert wieder auslesen.


Eine Mini-Singelton-Klasse ist beispielsweise diese hier:

PHP-Code:

class Meine_Singleton_Klasse {
  private static $Instance = null;
  private $wert;

  private function __construct() {
  }

  public static function getInstance() {
    if (Meine_Singleton_Klasse::Instance == null) {
      Meine_Singleton_Klasse::Instance = new Meine_Singleton_Klasse();
    }
    return Meine_Singleton_Klasse::Instance;
  }

  public function setWert($wert) {
    $this->wert = $wert;
  }

  public function getWert() {
    return $this->wert;
  }

  public function __clone() {
  }
} 


Die magic function __clone muss man (korrekterweise) überschreiben, damit man von außen die Instanz nicht klonen kann, sonst wärs keine Singleton mehr...

Mit dieser Klasse kann man damit dann z.B. folgendes machen:

PHP-Code:

<?php
// nach Einbinden der Klasse

$Eins = Meine_Singleton_Klasse::getInstance();
$Eins->setWert('muhaha');


$Zwei = Meine_Singleton_Klasse::getInstance();
echo $Zwei->getWert();

Ausgabe ist dann

muhaha

Btw. Ham wir dazu eigentlich ein Tutorial?
Ich kanns grad nicht testen, bei funktioniert irgendwie grad kein Suchbutton...

[Jann Hendrik]

Zitat von Jojo

Btw. Ham wir dazu eigentlich ein Tutorial?

Nein, haben wir leider nicht - ich nehme aber gerne dazu eines an!
Einfach schreiben und im Tutorial-Briefkasten posten.

[Basti]

Singletons sind letztlich nichts anderes, als globale Variablen und von daher geht das hier vielleicht ein wenig am Thema vorbei, denn die Vor- und Nachteile sind die selben.

Zentraler Nachteil von Globalen ist, dass dein Stückchen Code, also deine Klasse oder Funktion damit eine Schnittstelle zu einem anderen Teil deines Codes hat, der nicht so ganz transparent ist.

Wenn du die benötigten Objekte den Funktionen oder dem Konstruktor übergibst, dann tunnelst du quasi alle Abhängigkeiten (mehr oder weniger) und hast nicht noch irgendwelche Fehlerquellen rumschwirren, die von einem irgendwie undurchsichtigen Zustand deiner Anwendung abhängig sind.

Ich würde mir also sehr genau anschauen, welche Objekte wirklich von allen Klassen benötigt werden bzw. ob sich diese nicht besser über Fabriken übergeben lassen (die dann die Objekte kennen und den zu bauenden Objekten übergeben können, ohne dass die Klienten dieser Objekte etwas damit zu tun haben müssen).

Bastian