Variblen Global verfügbar machen

[Flex]

Stimmt, die Logik leuchtet mir natürlich ein.
Ich hoffe, dass in PHP6 sich noch einiges zur OOP Funktionalität tut...
Danke für die Erklärung.

 

[R00Ki3]

singleton pattern ist interressant für dinge die sich auf eine klasse alleine beziehen...
Ich nutze es zumbeispiel für die datenbank...
ansonsten gibt es auch die lösung registry...
Die klasse registry nimmt die objecte/variablen auf und gibt sie zurück und kann sie auch löschen...
Hier mal die Klasse:

class registry{
/**
 * @desc    Speichert ein Object der Class registry
 *
 * @var     object
 * @access     protected static
 */
    protected static $instance = null;
/**
 * @desc    Speichert Objecte so wie Alle weiteren Werte die Uebergeben werden
 *
 * @var     array
 * @access     protected static
 */
    protected $values = array();
/**
 * @desc    Erstellt ein Object der Class registry und speichert es in der Variable $this->instance
 *
 * @access     public static
 * @return    object
 */
    public static function getInstance(){
        if(self::$instance === null){
            self::$instance = new registry();
        }
        return self::$instance;
    }
/**
 * @desc    Konstruktor, ist eine geschuetzte Funktion.
 * Dies verhindert das mehr als 1 Object erstellt wird.
 * Auf die Klasse registry wird ueber die Funktion getInstance zugegriffen.
 * 
 *
 * @access     protected
 * @return    void
 */
    protected function __construct(){}
/**
 * @desc    Destruktor, ist eine geschuetzte Funktion.
 * Dies verhindert das Objecte von der Klasse registry von Hand geschlossen werden.
 *
 * @access     protected
 * @return    void
 */
    protected function __destruct(){
        unset($this);
    }
/**
 * @desc    Clone, die Funktion ist private, welches verhindert das mehr als 1 Object von registry existieren kann.
 *
 * @access     private
 * @return    void
 */
    private function __clone(){}
/**
 * @desc    Nimmt Werte entgegen und speichert sie in einem Array: $this->values
 *
 * @param     string        $key
 * @param    mixed        $value
 * @access     public
 * @return    void
 */
    public function set($key, $value){
        $this->values[$key] = $value;
    }
/**
 * @desc    Kontrolliert ob die gewuenschte Variable/Object vorhanden ist.
 * Falls ja wird die Variable/Object ausgeliefert.
 *
 * @param     string        $name
 * @access     public
 * @return    mixed
 * @see        registry::isregistry();
 */
    public function get($name){
        if($this->isregistry($name)){
            return $this->values[$name];
        }
        return false;
    }
/**
 * @desc    Kontrolliert ob die gewuenschte Variable/Object vorhanden ist.
 * Falls ja wird die Variable/Object geloescht.
 *
 * @param     string        $name
 * @access     public
 * @return    boolean
 * @see        registry::isregistry();
 */
    public function remove($name){
        if($this->isregistry($name)){
            unset($this->values[$name]);
            return true;
        }
        return false;
    }
/**
 * @desc    Kontrolliert ob die Variable/Object in der Klasse registry gespeichert ist.
 *
 * @param     string        $name
 * @access     public final
 * @return    boolean
 */
    public final function isregistry($name){
        return array_key_exists($name, $this->values);
    }
}

Hier ein verwendungszweck

$user = new User(...,...);
$config = parse_ini_file(...);
$registry = registry::getInstance();
$registry->set("user", $user);
$registry->set("config", $config);
/** Abfragen der werte **/
$getvalues = registry::getInstance();
$user = $getvalues -> get("user");
$config = $getvalues -> get("config");

 

[maeTimmae]

Hört mir auf mit Datenbankklassen im Singleton-Pattern - Ein Mal, und nie wieder. Sobald mal mehr als eine Verbindung, oder eine erweiterte Verbindungskontrolle notwendig wird, muss das komplette Gerüst umgebaut werden. Alternative: Eine statische "Hauptinstanz", die man singleton-ähnlich verwenden kann, die jedoch nicht die einzige Instanz sein muss, oder eine andere Lösung, wie zB über ein Registry-Pattern.

Des Weiteren ist deine Registry-Lösung auch nicht das Optimale: Was ist, wenn ich eine Registry registrieren möchte oder muss? Ist mit Singleton ja leider nicht möglich, für etwaige Strukturierungen aber durchaus sinnvoll.

Ein kleiner Tipp am Rande: Die PHP SPL ist ne wunderbare Sache, so würde zB ein

class Registry extends ArrayObject { /** ... */ }

sämtliche gets und sets ersparen und implementiert auch noch gleich Array-ähnliche Zugriffe.
Weiterhin noch ein Tipp: Die Empfehlungen für die Schreibweise in PHP orientiert sich stark an jenem für Java, so sollten zB Klassennamen (auch wenn intern auf lowercase ausgewertet) groß geschrieben werden.
Außerdem noch eine kleine Anmerkung zum phpDoc:
@desc ist, wenn nicht schon abgeschafft, zumindest deprecated und für die meisten Dokumentationstools unnötig.
@access beinhaltet nur die Sichtbarkeit
@static wird zur Kennzeichnung statischer Methoden und Eigenschaften verwendet.
@return sollte so speziell wie möglich oder so abstrakt wie nötig angegeben werden. In dem Fall deiner Registry-Klasse würde zB "@return registry" klarer ausfallen.

 

[spex]

Hi,

nach Monaten nun hab ich mich für folgende Möglichkeit entschieden.
http://pastebin.com/mfaf5807

Die Datei einmal per require_once geladen und fertg.
So kann ich simplest per CONFIG::$db['first']['username'] etwa den Benutzername der Datenbank abfragen.
Naja und für Configfiles brauch ich ja kein Singleton-Pattern.

Gruß - sp3x