Ankündigung

Einklappen
Keine Ankündigung bisher.

Registry Klasse

Einklappen

Neue Werbung 2019

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

  • Registry Klasse

    Hallo,
    hab mal ne Frage: Wie programmier ich in PHP am besten eine Registry ?

    Hab mir mehrere mögliche Ansätze überlegt und wollte mal fragen was davon der beste ist.

    Also Version 1 wäre einfach eine Klasse die ein verschachteltes Array enthält und dort werden dann die Infos gelagert und abgefragt.

    Version 2 wäre eine Klasse die mehrere Objekte enthält die die einzelnen Äste der Registry darstellen, diese Objekte können beliebig weit verschachtelt werden.

    Version 3 wäre eine Klasse die intern das ganz an einen XML-Parser weiterleitet, da sich eine Registry ja nicht viel anders Verhält wie ein XML-Dokument.

    Dazu kommen aber noch spezielle Anforderungen:
    1. Ich will eine Zugriffsbeschränkung einbauen, d.h. bestimmte Werte dürfen nur von den Objekten geändert werden die sie erstellt haben.

    2. Ich würde gern die Werte so auslesen können: "user/lastLogin/timestamp"

    Alles in allem tendiere ich zu den Objekten (Version 2) da sich damit das ganze am einfachsten erstellen lassen würde.

    Was haltet ihr davon ?

    Grüße
    Signatur:
    PHP-Code:
    $s '0048656c6c6f20576f726c64';
    while(
    $i=substr($s=substr($s,2),0,2))echo"&#x00$i;"


  • #2
    Halt es einfach, eine Verschachtelung ist genausowenig nötig wie eine XML-Abbildung.
    "Mein Name ist Lohse, ich kaufe hier ein."

    Kommentar


    • #3
      2. Ich würde gern die Werte so auslesen können: "user/lastLogin/timestamp"
      Halte ich für schwierig (aus eigener Erfahrung). Stell Dir vor, Du legst in user/ ein Array ab. Dann entsteht die Frage, wie Du auf dessen Elemente zugreifen kannst. Via Pfad? Dann verlierst Du die Arraystryuktur beim Zugriff auf user/. Via Array-Schlüssel? Dann bekommst Du IMHO eine inkonsistente Registry.

      1. Ich will eine Zugriffsbeschränkung einbauen
      Sowas könnte man einfach mit mehreren Kontext-gebundenen Registries erreichen. Alle globalen Werte sind dann meinetwegen Kontext „global“ (default).
      --

      „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
      Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


      --

      Kommentar


      • #4
        Halt es einfach, eine Verschachtelung ist genausowenig nötig wie eine XML-Abbildung.
        Naja ich halte ein verschachtelung schon für nötig, damit man sozusagen einzelne bereiche machen kann, die dann Werte enthalten...
        So vom Prinzip Namespaces in PHP.
        Möglich wäre es natürlich auch ein Präfix zu vergeben: hans:wert1, hans:wert2,
        bob:wert1, bob:wert2

        1. Ich will eine Zugriffsbeschränkung einbauen
        Sowas könnte man einfach mit mehreren Kontext-gebundenen Registries erreichen. Alle globalen Werte sind dann meinetwegen Kontext „global“ (default).
        Ich bin mir nun nicht sicher ob ich richtig verstehe wie du das meinst ?
        Soll ich für jedes Objekt sozusagen seine private Registry machen ?
        Andere Objekte sollen die Werte die geschützt gespeichert wurden auslesen können, jedoch nicht überschreiben können...

        Zitat:
        2. Ich würde gern die Werte so auslesen können: "user/lastLogin/timestamp"
        Halte ich für schwierig (aus eigener Erfahrung). Stell Dir vor, Du legst in user/ ein Array ab. Dann entsteht die Frage, wie Du auf dessen Elemente zugreifen kannst. Via Pfad? Dann verlierst Du die Arraystryuktur beim Zugriff auf user/. Via Array-Schlüssel? Dann bekommst Du IMHO eine inkonsistente Registry.
        Also ich hab mir das ungefähr so gedacht wie du das gesagt hast einfach ein Array runterlaufen und immer anhand der Array-Schlüssel zum nächsten Unterpunkt weiter, ...

        Grüße
        Signatur:
        PHP-Code:
        $s '0048656c6c6f20576f726c64';
        while(
        $i=substr($s=substr($s,2),0,2))echo"&#x00$i;"

        Kommentar


        • #5
          Andere Objekte sollen die Werte die geschützt gespeichert wurden auslesen können, jedoch nicht überschreiben können...
          Hattest DU bisher noch nicht geschrieben.

          Also ich hab mir das ungefähr so gedacht wie du das gesagt hast einfach ein Array runterlaufen und immer anhand der Array-Schlüssel zum nächsten Unterpunkt weiter, ...
          Dannüberleg mal, wie Du das abbilden willst:

          PHP-Code:
          Registry::set('/user' 'abc');
          Registry::set('/user/xyz/zyx' 1); 
          1. Ist User zunächst ein Wert, kein Array. Wohin wandert also der Wert bei einer Zuweisung eines Unterschlüssels?
          2. Gibts den Schlüssel xyz nicht. Wird der jetzt angelegt? Und was liefert ein Zugriff auf /user später?
          --

          „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
          Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


          --

          Kommentar


          • #6
            1. Ich will eine Zugriffsbeschränkung einbauen, d.h. bestimmte Werte dürfen nur von den Objekten geändert werden die sie erstellt haben.
            Damit wollte ich das eigentlich ausdrücken...

            Ok ich geb zu das mit den user/bin/wert ist ein bissl unpraktisch ^^

            Aber grundsätzlich sind doch dann Objekte am besten ?

            OK hab jetzt mal ne Rohstruktur gebastelt, nur irgendwie gefällt mir das noch net so recht, da ich den gleichen Code ansich 2mal hab...

            PHP-Code:
            <?php
            error_reporting
            (-1);
            /*abstract*/ class RegistryAbstract
            {
                protected static 
            $registry = array();
                
                public static function 
            createTrunk($name null)
                {
                    if (!
            array_key_exists($nameself::$registry))
                    {
                        
            self::$registry[$name] = new RegistryTrunk();
                        return 
            self::$registry[$name];
                    }

                    return 
            null;
                }

                public static function 
            setNode($name null$value null)
                {
                    
            self::$registry[$name] = $value;
                }

                public static function 
            getNode($name null)
                {
                    if (
            array_key_exists($nameself::$registry))
                    {
                        return 
            self::$registry[$name];
                    }

                    return 
            null;
                }

                public static function 
            getAll(){
                    return 
            self::$registry;
                }
                
            }

            /*abstract*/ class RegistryTrunk
            {
                protected 
            $registry = array();

                public function 
            createTrunk($name null)
                {
                    if (!
            array_key_exists($name$this->registry))
                    {
                        
            $this->registry[$name] = new RegistryTrunk();
                        return 
            $this->registry[$name];
                    }

                    return 
            null;
                }

                public function 
            setNode($name null$value null)
                {
                    
            $this->registry[$name] = $value;
                }

                public function 
            getNode($name null)
                {
                    if (
            array_key_exists($name$this->registry))
                    {
                        return 
            $this->registry[$name];
                    }

                    return 
            null;
                }

            }

            RegistryAbstract::createTrunk('user')->addNode('name''tester');
            RegistryAbstract::addNode('time'time());

            echo 
            '<pre>';
            print_r(RegistryAbstract::getAll());
            echo 
            '</pre>';

            echo 
            RegistryAbstract::getNode('user')->getNode('name');
            Eventuell im RegistryAbstract einfach direkt einen RegistryTrunk anlegen und dann immer auf den zugreifen, dann muss man net alles verdoppeln ?

            Die Überprüfungssachen fehlen alle noch, is nur mal die Grundidee...

            plz Feedback
            Signatur:
            PHP-Code:
            $s '0048656c6c6f20576f726c64';
            while(
            $i=substr($s=substr($s,2),0,2))echo"&#x00$i;"

            Kommentar


            • #7
              Warum eine abstrakte Registry? Das Pattern beschreibt die Idee des zentralen Zugriffs, was mich zur Aussage verleiten würde, dass es in einer Applikation nur eine geben sollte. Siehe P of EAA: Registry
              Viele Grüße,
              Dr.E.

              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
              1. Think about software design before you start to write code!
              2. Discuss and review it together with experts!
              3. Choose good tools (-> Adventure PHP Framework (APF))!
              4. Write clean and reusable software only!
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

              Kommentar


              • #8
                Mmh, auf phpbar ist es ebenfalls als abstract gezeigt, mit der Begründung:
                Die Registry kann als abstract deklariert werden, da nur statische Attribute und Methoden verwendet werden.

                Registry - php bar

                Wie wäre es deiner Meinung nach richtig? Singleton?
                Tutorials zum Thema Technik:
                https://pilabor.com
                https://www.fynder.de

                Kommentar


                • #9
                  Das als abstract auf Grund der Instanziierungs-Thematik zu bezeichnen halte ich für einen semantischen Fehler. Der Modifier "abstract" ist ein Mittel der Vererbung.

                  Die Klasse wird zwar keine Instanz haben, aus diesem Grund sollte man das explizit mit einem privaten Konstruktur und statischen Methoden sowie einem statischen, privaten Container für die Werte verhindern. Ein Singleton ist es deswegen noch lange nicht, denn bei einem solchen würde es ja eine Instanz geben.

                  Korrekt wäre IMHO also folgendes:
                  PHP-Code:
                  final class Registry {
                     private static 
                  $container;
                     public static 
                  get(...){}
                     public static 
                  set(...){}

                  Viele Grüße,
                  Dr.E.

                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                  1. Think about software design before you start to write code!
                  2. Discuss and review it together with experts!
                  3. Choose good tools (-> Adventure PHP Framework (APF))!
                  4. Write clean and reusable software only!
                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                  Kommentar


                  • #10
                    Man könnte es aber auch mit einer Art Factory umsetzen. Ich habe mir mal eine Registry gebaut, die verschiedene Adapter aufnehmen konnte (Normal in eine Variable speichern, DB, Datei, ...). Dann wären Instanzen sinnvoll (evtl. über ein parametrisiertes Singleton), da man diesen dann verschiedene Adapter zuweisen könnte.

                    Kommentar


                    • #11
                      Das ist dann aber keine echte Registry mehr sondern eher ein ServiceLocator/ServiceManager/Factory...
                      Viele Grüße,
                      Dr.E.

                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                      1. Think about software design before you start to write code!
                      2. Discuss and review it together with experts!
                      3. Choose good tools (-> Adventure PHP Framework (APF))!
                      4. Write clean and reusable software only!
                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                      Kommentar

                      Lädt...
                      X