OOP: Statische Eigenschaften

Hallo

Ich habe folgende Situation

PHP-Code:

class Core{

    private $error = NULL; // Error-Objekt
    
 
    public function __construct(){
        
    /* Error-Objekt reinholen */ 
        global $error;
        $this->error = $error; 
        
    }
   
    public static function newError(){
      $this->error->triggerError();
    }
} 


triggerError() ist eine nicht-statische Funktion des Error-Objekts, dass ich im Konstruktor via global reinhole. Es gibt nur ein einziges Errorobjekt im gesamten Skript, deshalb diese Vorgehensweise.
Natürlich funktioniert $this.. in einer statischen Funktion newError() nicht. Wie sonst könnte ich es machen?
Wenn ich die Eigenschaft $error via private static $error statisch deklariere, gehts ja auch nicht. Ich kann in newError() ja nicht mit self::error->triggerError() aufrufen - dies gibt mir einen Syntaxfehler aus.

Danke und hoffe war nicht zu kompliziert.

Zitat von tim-gt

Ich kann in newError() ja nicht mit self::error->triggerError() aufrufen - dies gibt mir einen Syntaxfehler aus.

Richtig wäre ja auch self::$error

global hat in objektorientierter Programmierung überhaupt nix verloren.

PHP-Code:

class Core {

    private $error = NULL; // Error-Objekt
 
    public function __construct($error){
        /* Error-Objekt reinholen */ 
        $this->error = $error; 
    }
   
    public function newError(){
        $this->error->triggerError();
    }
} 


Außerdem solltest du dir mal Exceptions anschauen:

http://de.php.net/manual/en/language.exceptions.php

global $error? "reinholen"? *autsch*

Wenn es sowieso nur ein Error-Objekt geben kann, dann mach das zum Singleton und benutze Error::getInstance().

Mit Patterns habe ich mich noch nicht auseinandergesetzt ;-)

Meine aktuelle Lösung sieht jetzt so aus:

PHP-Code:

class Core{

    private static $error = NULL; // Error-Objekt
    
 
    public function __construct(){
        

        
    }
   
    public static function newError(){
       global $error;
       self::$error = $error;
       self::$error->triggerError();
    }
} 


Ich weiss, es ist nicht schön.. Aber mit Singletons muss ich mich erst noch auseinandersetzen. Mit Exceptions bin ich schon dran.. ich verwende ein Debugging-System, das set_error_handler() und Exceptions kombiniert. Ich werde es dann einmal hier posten.
Danke für die Hilfe.

Gib das global weg!!!

Du brauchst doch gar kein Property dafür!

PHP-Code:

class Core{
    public static function newError(){
       global $error;
       $error->triggerError();
    }
} 


Aber mal ehrlich, warum dieser Umweg über Core? Es gibt offenbar im Calling Scope keine Instanz von Core, weshalb du newError() statisch machen musst. Da wäre es doch viel einfacher, statt Core::newError() gleich das globale Error-Objekt zu benutzen. Mehr macht newError() doch auch nicht!

Ich hab die Funktionsnamen nur zur Illustration verwendet.
Core ist eine Basisklasse, die vor allem statische Methoden zur Stringformatierung etc. enthält. Passiert in einer dieser Methode ein Fehler, wird die Methode triggerError der Klasse Error aufgerufen oder eine Exception geworfen, die mit catchExceptions der Klasse Error abgefangen werden kann (formatierte Ausgabe von Backtrace etc). Ich möchte jetzt nicht die ganze Struktur erklären, danke euch aber für den Hinweis auf Singleton, habe mich schlau gemacht auf PHP: Pattern - Manual und nun sieht die Sache so aus:

Error-Klasse:

PHP-Code:


 class Error {
         private static $instance;
         
         private function __construct(){
         //...
         }

        public static function generate(){
           if(!isset(self::$instance)) {
              $class = __CLASS__;
              self::$instance = new $class;
            }
            return self::$instance;
          }  
} 


Core-Klasse

PHP-Code:

 class Core {
          private static $error;
          
          public function __construct(){
          //...
          }
 
   public static function formatRootRemove($str, $root = DOCUMENTROOT){
    /* Error-Objekt reinholen */
    self::$error = Error::generate();

    $root =preg_replace('!/!','\\',$root);            // Slash zu Backslash ändern  und Kurzform generieren
        $str = str_replace($root,'',$str, $count);
        if($count === 0){
      self::$error->triggerError('Needle \''.$root.'\' nicht in Haystack \''.$str.'\' gefunden.',__LINE__,__FILE__,E_USER_NOTICE);
        } else {
            return $str;
        }
} 


formatRootRemove() entfernt wie schon erwähnt standardmässig den Rootfolder einer Datei.

Mir fällt grad noch ein, generate() ist wohl der falsche Name für die Methode. getInstance() macht wirklich mehr Sinn.. ;-)

Jetzt noch auf die Property verzichten, dann ist es perfekt.

PHP-Code:

class Core {
    public function __construct(){
         //...
    }

    public static function formatRootRemove(...){
        // ...
        if($count === 0) {
            Error::getInstance()->triggerError(...);
        }
    }
} 


Also du meinst so:

PHP-Code:


$error = Error::generate();
$error->triggerError(..); 


Hier macht das m.E. schon Sinn, spart ein paar Zeilen. Aber wenn ich
v.a. mit nicht-statischen Methoden arbeite, sollte ich Error::generate() ja im Konstruktor der jeweiligen Klasse aufrufen und das $error-Objekt private abspeichern, oder nicht?

Zitat von tim-gt

Aber wenn ich v.a. mit nicht-statischen Methoden arbeite, sollte ich Error::generate() ja im Konstruktor der jeweiligen Klasse aufrufen und das $error-Objekt private abspeichern, oder nicht?

Nein. Wozu?

Sonst muss ich es ja in jeder nicht-statischen Funktion, in der ich es brauche, neu "generieren"..?

Aber es ist doch ein Singleton, d.h. nur beim ersten Aufruf von getInstance() wird da was "generiert". Bei jedem weiteren Aufruf wird nur das zurück gegeben, was eh schon da ist.

Ja, "generieren" nenn ich es nur, weil meine Funktion fälschlicherweise "generate()" heisst. Ich meinte damit, dass eine Methode ja keinen Zugriff auf ausserhalb der Klasse deklarierte Objekte hat, weshalb ich dann bei jeder Klasse, in der ich das einmalige Error-Objekt verwenden will, eine Eigenschaft mit dem Objekt belegen muss -> dieses Objekt kann dann von allen Methoden innerhalb der Klasse verwendet werden. Oder bin ich etwa komplett auf dem Holzweg? Natürlich kann ich das Error-Objekt auch in jeder Methode von neuem wieder mit Error::generate() "reinholen"...

Ich würde es wie gesagt nicht im Konstruktor "reinholen" und in ein Property speichern. Finde es besser, wenn man wirklich bei jeder Verwendung mit getInstance() arbeitet. Dann sieht auch ein Fremder sofort was dahinter steckt (Singleton).
Und das was du da in der Property speichern willst, ist sowieso nur eine Referenz auf das Objekt, die selbe Referenz, die auch getInstance() liefert. Faktisch passiert also bei $this->error->... das selbe wie bei Error::getInstance()->...

Zum "reinholen" an sich: Du musst das Error-Objekt nicht reinholen. Es lebt irgendwo außerhalb. Du willst es gar nicht im Scope der Klasse haben und eigentlich auch keine Referenz darauf. Du willst ihm eigentlich nur eine Nachricht zukommen lassen, wenn es einen Fehler gab. Sieh es einfach so, dann wird es vielleicht verständlicher.