OOP: Statische Eigenschaften

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • 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.

  • #2
    Zitat von tim-gt Beitrag anzeigen
    Ich kann in newError() ja nicht mit self::error->triggerError() aufrufen - dies gibt mir einen Syntaxfehler aus.
    Richtig wäre ja auch self::$error

    Kommentar


    • #3
      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
      Zuletzt geändert von h3ll; 14.07.2009, 15:35.

      Kommentar


      • #4
        global $error? "reinholen"? *autsch*

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

        Kommentar


        • #5
          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.

          Kommentar


          • #6
            Gib das global weg!!!

            Kommentar


            • #7
              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!

              Kommentar


              • #8
                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.. ;-)
                Zuletzt geändert von tim-gt; 14.07.2009, 16:07.

                Kommentar


                • #9
                  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(...);
                          }
                      }

                  Kommentar


                  • #10
                    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?

                    Kommentar


                    • #11
                      Zitat von tim-gt Beitrag anzeigen
                      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?

                      Kommentar


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

                        Kommentar


                        • #13
                          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.

                          Kommentar


                          • #14
                            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"...

                            Kommentar


                            • #15
                              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.

                              Kommentar

                              Lädt...
                              X